1.赛事详情

杨帅
1 parent f4aa2c68
Showing 27 changed files with 1051 additions and 60 deletions
library_baidumap/build.gradle
library_baidumap/libs/BaiduTraceSDK_v3_1_0.jar
library_baidumap/libs/bos-android-sdk-1.0.3.jar
library_baidumap/libs/okhttp-3.8.1.jar
library_baidumap/libs/okio-1.13.0.jar
library_baidumap/src/main/AndroidManifest.xml
library_baidumap/src/main/java/com/cnlive/baidumap/InitBaidu.java
library_baidumap/src/main/jniLibs/arm64-v8a/libBaiduTraceSDK_v3_1_0.so
library_baidumap/src/main/jniLibs/armeabi-v7a/libBaiduTraceSDK_v3_1_0.so
library_baidumap/src/main/jniLibs/armeabi/libBaiduTraceSDK_v3_1_0.so
library_baidumap/src/main/jniLibs/x86/libBaiduTraceSDK_v3_1_0.so
library_baidumap/src/main/jniLibs/x86_64/libBaiduTraceSDK_v3_1_0.so
moudle_pedometer/build.gradle
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/frame/presenter/RunningMapFragmentPresenter.java
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/frame/view/RunMainFragmentView.java
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/frame/view/RunRaceDetailFragmentView.java
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/frame/view/RunningMapFragmentView.java
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/model/Constant.java
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/service/StepService.java
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/ui/fragment/RunningMapFragment.java
@@ -43,4 +43,11 @@ dependencies {
     implementation "com.alibaba:arouter-api:$rootProject.arouterApiVersion"
     annotationProcessor "com.alibaba:arouter-compiler:$rootProject.arouterCompilerVersion"
     api files('libs/BaiduLBS_Android.jar')
+    api files('libs/BaiduTraceSDK_v3_1_0.jar')
+    api files('libs/bos-android-sdk-1.0.3.jar')
+//    api files('libs/okhttp-3.8.1.jar')
+//    api files('libs/okio-1.13.0.jar')
+
 }
+
+
@@ -24,6 +24,12 @@
             android:name="com.baidu.location.f"
             android:enabled="true"
             android:process=":remote" />
+
+        <service
+            android:name="com.baidu.trace.LBSTraceService"
+            android:enabled="true"
+            android:process=":remote"></service>
+
         <activity android:name="com.cnlive.baidumap.BaiduMapMainActivity"></activity>
     </application>
  
-package com.cnlive.baidumap;
-
-import android.content.Context;
-
-import com.baidu.mapapi.CoordType;
-import com.baidu.mapapi.SDKInitializer;
-
-public class InitBaidu {
-    public static void init(Context context) {
-        //在使用SDK各组件之前初始化context信息，传入ApplicationContext
-        SDKInitializer.initialize(context);
-        //自4.3.0起，百度地图SDK所有接口均支持百度坐标和国测局坐标，用此方法设置您使用的坐标类型.
-        //包括BD09LL和GCJ02两种坐标，默认是BD09LL坐标。
-        SDKInitializer.setCoordType(CoordType.GCJ02);
-    }
-}
@@ -110,3 +110,9 @@ dependencies {
     implementation project(':library_baidumap')
  
 }
+
+configurations {
+    all*.exclude group: 'com.squareup.okhttp3', module: 'okhttp'
+    all*.exclude group: 'com.squareup.okio'
+
+}
 package com.cnlive.moudle.pedometer.frame.presenter;
  
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.widget.Toast;
+
+import com.baidu.mapapi.map.BitmapDescriptorFactory;
+import com.baidu.mapapi.map.MarkerOptions;
+import com.baidu.mapapi.map.OverlayOptions;
+import com.baidu.mapapi.model.LatLng;
+import com.baidu.trace.api.entity.EntityListResponse;
+import com.baidu.trace.api.entity.OnEntityListener;
+import com.baidu.trace.api.entity.UpdateEntityResponse;
+import com.baidu.trace.api.track.HistoryTrackRequest;
+import com.baidu.trace.api.track.HistoryTrackResponse;
+import com.baidu.trace.api.track.LatestPointResponse;
+import com.baidu.trace.api.track.OnTrackListener;
+import com.baidu.trace.api.track.SupplementMode;
+import com.baidu.trace.api.track.TrackPoint;
+import com.baidu.trace.model.ProcessOption;
+import com.baidu.trace.model.SortType;
+import com.baidu.trace.model.StatusCodes;
+import com.baidu.trace.model.TraceLocation;
+import com.baidu.trace.model.TransportMode;
 import com.cnlive.moudle.pedometer.frame.view.RunningMapFragmentView;
+import com.cnlive.moudle.pedometer.model.Constant;
+import com.cnlive.moudle.pedometer.service.StepService;
+import com.cnlive.moudle.pedometer.utils.BitmapUtil;
+import com.cnlive.moudle.pedometer.utils.CommonUtil;
+import com.cnlive.moudle.pedometer.utils.MapUtil;
+import com.cnlive.moudle.pedometer.utils.MyMapUtil;
+import com.example.moudle_pedometer.R;
 import com.hannesdorfmann.mosby3.mvp.MvpBasePresenter;
  
+import java.util.ArrayList;
+import java.util.List;
+
 public class RunningMapFragmentPresenter extends MvpBasePresenter<RunningMapFragmentView> {
+    /******轨迹查询相关******/
+    //分页大小
+    private int pageSize = 1000;
+    //分页索引
+    private int pageIndex = 1;
+    /**
+     * 历史轨迹请求
+     */
+    private HistoryTrackRequest historyTrackRequest;
+    /**
+     * 轨迹点集合
+     */
+    private List<LatLng> trackPoints;
+
+    /**
+     * 查询历史轨迹
+     *
+     * @param startTime
+     * @param endTime
+     */
+    public void queryHistoryTrace(Context context, String entityName, long startTime, long endTime) {
+        if (historyTrackRequest == null) {
+            historyTrackRequest = new HistoryTrackRequest();
+            //设置查询设备名称
+            historyTrackRequest.setEntityName(entityName);
+            //历史轨迹开始时间
+            historyTrackRequest.setStartTime(startTime);
+            //历史轨迹结束时间
+            historyTrackRequest.setEndTime(endTime);
+            //分页索引
+            historyTrackRequest.setPageIndex(pageIndex);
+            //分页大小
+            historyTrackRequest.setPageSize(pageSize);
+            //设置是否进行纠偏
+            historyTrackRequest.setProcessed(true);
+            //其他设置
+            ProcessOption processOption = new ProcessOption();
+            //去噪：可设置是否需要去除角度、速度和方向异常的轨迹点
+            processOption.setNeedDenoise(true);
+            //绑路：设置是否将轨迹点绑定至路网道路
+            processOption.setNeedMapMatch(false);
+            //抽稀：设置是否进行抽稀处理，对冗余的轨迹点进行抽稀去除处理，如一条直线上除起终点外的多个轨迹点
+            processOption.setNeedVacuate(true);
+            //自动判断交通方式
+            processOption.setTransportMode(TransportMode.auto);
+            // 设置精度过滤值(定位精度大于100米的过滤掉)
+            processOption.setRadiusThreshold(100);
+            // 设置纠偏选项
+            historyTrackRequest.setProcessOption(processOption);
+            // 设置里程填充方式为驾车
+            historyTrackRequest.setSupplementMode(SupplementMode.walking);
+
+        }
+        if (trackPoints == null) {
+            trackPoints = new ArrayList<>();
+        }
+        //轨迹查询监听器
+        OnTrackListener historyTrackListener = new OnTrackListener() {
+            @Override
+            public void onHistoryTrackCallback(HistoryTrackResponse response) {
+                super.onHistoryTrackCallback(response);
+                int total = response.getTotal();
+                if (StatusCodes.SUCCESS != response.getStatus()) {
+                } else if (0 == total) {
+                    Toast.makeText(context, "暂未查到您的轨迹,请稍后重试!", Toast.LENGTH_SHORT).show();
+                } else {
+                    //查询到轨迹
+                    List<TrackPoint> points = response.getTrackPoints();
+                    if (null != points) {
+                        for (TrackPoint trackPoint : points) {
+                            if (!CommonUtil.isZeroPoint(trackPoint.getLocation().getLatitude(),
+                                    trackPoint.getLocation().getLongitude())) {
+                                //将轨迹点转换为地图坐标点
+                                trackPoints.add(MyMapUtil.convertTrace2Map(trackPoint.getLocation()));
+                            }
+                        }
+                    }
+                }
+                if (total > pageSize * pageIndex) {
+                    historyTrackRequest.setPageIndex(++pageIndex);
+                    queryHistoryTrace(context, entityName, startTime, endTime);
+                } else {
+                    if (getView() != null) {
+                        MyMapUtil.drawHistoryTrack(context, getView().baiduMap, trackPoints, SortType.asc, R.color.red, R.drawable.icon_start, R.drawable.run_map_icon_end);
+                    }
+                }
+            }
+
+            @Override
+            public void onLatestPointCallback(LatestPointResponse latestPointResponse) {
+                super.onLatestPointCallback(latestPointResponse);
+                if (StatusCodes.SUCCESS != latestPointResponse.getStatus()) {
+                } else {
+                    Bitmap startPointBitmap = BitmapUtil.getBitmapFromDp(context, BitmapFactory.decodeResource(context.getResources(), R.drawable.run_map_icon_start), 40, 40);
+                    OverlayOptions startOptions = new MarkerOptions()
+                            .position(MyMapUtil.convertTrace2Map(latestPointResponse.getLatestPoint().getLocation())).icon(BitmapDescriptorFactory.fromBitmap(startPointBitmap));
+                    if (getView() != null) {
+                        getView().baiduMap.addOverlay(startOptions);
+                    }
+                }
+            }
+        };
+        //开始查询历史轨迹
+        if (StepService.mClient != null) {
+            StepService.mClient.queryHistoryTrack(historyTrackRequest, historyTrackListener);
+
+        }
+
+    }
+
 }
@@ -34,6 +34,7 @@ public class RunMainFragmentView implements MvpView {
     private int stopIndex = 0;//停止按钮,计数
     private Handler handler;
     private Runnable runnable;
+    private Runnable animRunnable;
  
     private long mRecordTime;//计时时间
     private boolean firstTimeFlag;//是否是首次计时
@@ -217,31 +218,39 @@ public class RunMainFragmentView implements MvpView {
  
                         ButtonAnimUtil.setViewZoomIn(fragment.binding.flStop);
                         stopStartFlag = true;
-                        runnable = new Runnable() {
+                        animRunnable = new Runnable() {
                             @Override
                             public void run() {
                                 if (stopStartFlag) {
                                     stopIndex += 5;
                                     if (stopIndex <= 100) {
-                                        handler.postDelayed(runnable, 20);
+                                        handler.postDelayed(animRunnable, 20);
                                         fragment.binding.cpCurrent.setProgress(stopIndex);
                                         fragment.binding.flStopTip.setVisibility(View.VISIBLE);
                                         if (stopIndex == 100) {
                                             //
                                             fragment.binding.flStopTip.setVisibility(View.INVISIBLE);
  
+
                                             SelectDialog selectDialog = new SelectDialog(fragment.getActivity(), "确定结束运动吗?", "确定", new SelectDialog.DialogInterface() {
                                                 @Override
                                                 public void onClick(SelectDialog dialog) {
+                                                    fragment.binding.cpCurrent.setVisibility(View.GONE);
+                                                    ButtonAnimUtil.setViewDefault(fragment.binding.flStop);
                                                     fragment.getActivity().stopService(new Intent(fragment.getActivity(), StepService.class));
                                                     //清空数据
                                                     StepUtil.clearRunData(getContext(), uid);
                                                     dialog.dismiss();
+                                                    if (StepService.mClient != null) {
+                                                        StepService.mClient.stopGather(StepService.traceListener);
+                                                    }
 //                                                    fragment.getActivity().finish();
                                                 }
                                             }, "取消", new SelectDialog.DialogInterface() {
                                                 @Override
                                                 public void onClick(SelectDialog dialog) {
+                                                    fragment.binding.cpCurrent.setVisibility(View.GONE);
+                                                    ButtonAnimUtil.setViewDefault(fragment.binding.flStop);
                                                     dialog.cancel();
                                                 }
                                             });
@@ -254,7 +263,7 @@ public class RunMainFragmentView implements MvpView {
                                 }
                             }
                         };
-                        handler.postDelayed(runnable, 20);
+                        handler.postDelayed(animRunnable, 20);
  
                     }
                 } else if (motionEvent.getAction() == MotionEvent.ACTION_UP) {
@@ -44,8 +44,6 @@ import com.baidu.mapapi.search.route.WalkingRouteResult;
 import com.cnlive.moudle.pedometer.ui.activity.PedometerMainActivity;
 import com.cnlive.moudle.pedometer.ui.activity.RaceRecordActivity;
 import com.cnlive.moudle.pedometer.ui.activity.RegistrationInfoActivity;
-import com.cnlive.moudle.pedometer.ui.activity.RunningMapActivity;
-import com.cnlive.moudle.pedometer.ui.fragment.RunMainFragment;
 import com.cnlive.moudle.pedometer.ui.fragment.RunRaceDetailFragment;
 import com.cnlive.moudle.pedometer.utils.BitmapUtil;
 import com.cnlive.moudle.pedometer.utils.ScreenUtil;
@@ -53,8 +51,8 @@ import com.example.moudle_pedometer.R;
 import com.hannesdorfmann.mosby3.mvp.MvpView;
 import com.sothree.slidinguppanel.SlidingUpPanelLayout;
  
-import java.io.LineNumberReader;
 import java.util.ArrayList;
+import java.util.LinkedList;
 import java.util.List;
  
 public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
@@ -68,7 +66,7 @@ public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
     private BitmapDescriptor mCurrentMarker;//定位图标
     private static int accuracyCircleFillColor;
     private static int accuracyCircleStrokeColor;
-    private static MyLocationData mylocation;
+    private static MyLocationData followMyLocation;
     boolean isFirstLoc = true; // 是否首次定位
     private MarkerOptions currentMark;
     private MarkerOptions endMark;
@@ -77,8 +75,8 @@ public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
     private LatLng firstLatLng;
     private Double lastX = 0.0;
     private int mCurrentDirection = 0;
-    private double mCurrentLat = 0.0;
-    private double mCurrentLon = 0.0;
+    //    private double mCurrentLat = 0.0;
+//    private double mCurrentLon = 0.0;
     private float mCurrentAccracy;
     // 定位相关
     private LocationClient mLocClient;
@@ -92,8 +90,8 @@ public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
     private String startPoint = "首都师范大学南门";
     private String endPoint = "首都师范大学篮球场";
  
-    private List<LatLng> importLatLngs;//关键点
-    private LatLng startLatLng = new LatLng(39.934266, 116.309228);//起始点
+    private LinkedList<LatLng> importLatLngs;//关键点
+    private LatLng startLatLng = new LatLng(39.934733, 116.308646);//起始点
  
     public RunRaceDetailFragmentView(RunRaceDetailFragment fragment) {
         this.fragment = fragment;
@@ -109,17 +107,20 @@ public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
         }
         initMap();
         //初始化运营人员所选的关键点
-        importLatLngs = new ArrayList<>();
-        //北轨山区社区
-//        importLatLngs.add(new LatLng(39.933295, 116.308663));
-        //中国体育彩票
-        importLatLngs.add(new LatLng(39.933065, 116.309838));
-        //花园桥招待所
-        importLatLngs.add(new LatLng(39.933094, 116.310927));
-//        //砂锅时代问题
-//        importLatLngs.add(new LatLng(39.933481, 116.311834));
-//        //好邻居便利店
-        importLatLngs.add(new LatLng(39.933736, 116.312365));
+        importLatLngs = new LinkedList<>();
+//        importLatLngs.add(new LatLng(39.935861,116.308621));
+//        importLatLngs.add(new LatLng( 39.934948,116.308605));
+//        importLatLngs.add(new LatLng( 39.934516,116.3086));
+//        importLatLngs.add(new LatLng( 39.934121,116.30861));
+//        importLatLngs.add(new LatLng( 39.934105,116.308605));
+//
+//
+//        importLatLngs.add(new LatLng( 39.933702,116.3086));
+        importLatLngs.add(new LatLng(39.933890, 116.308726));
+        importLatLngs.add(new LatLng(39.933943, 116.309627));
+        importLatLngs.add(new LatLng(39.934733, 116.309515));
+        importLatLngs.add(new LatLng(39.934733, 116.308742));
+
  
 //        searchRouteResult(new LatLng(39.934266, 116.309228), new LatLng(39.939756, 116.319766), 0);
  
@@ -269,7 +270,7 @@ public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
     /**
      * 开始路线规划
      */
-    public void searchRouteResult(LatLng StartPoint, LatLng EndPoint, int index) {
+    public void searchRouteResult(LatLng StartPoint, LatLng EndPoint, int index, int listSize) {
         Log.e(TAG, "searchRouteResult: ");
         float currentZoom = baiduMap.getMapStatus().zoom;
         // 设置起终点信息，对于tranist search 来说，城市名无意义
@@ -278,7 +279,6 @@ public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
         routePlanSearch.setOnGetRoutePlanResultListener(new OnGetRoutePlanResultListener() {
             @Override
             public void onGetWalkingRouteResult(WalkingRouteResult walkingRouteResult) {
-                Log.e(TAG, "onGetWalkingRouteResult: ");
                 if (fragment.getActivity() == null) {
                     return;
                 }
@@ -293,7 +293,9 @@ public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
                 if (walkingRouteResult.getRouteLines() != null) {
                     if (walkingRouteResult.getRouteLines().get(0).getAllStep().get(0).getWayPoints().size() > 0) {
                         //添加起点坐标
-//                        points.add(StartPoint);
+                        if (index == 0) {
+                            points.add(StartPoint);
+                        }
                         for (int i = 0; i < walkingRouteResult.getRouteLines().get(0).getAllStep().size(); i++) {
                             for (int j = 0; j < walkingRouteResult.getRouteLines().get(0).getAllStep().get(i).getWayPoints().size(); j++) {
                                 points.add(walkingRouteResult.getRouteLines().get(0).getAllStep().get(i).getWayPoints().get(j));
@@ -301,9 +303,9 @@ public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
                         }
                     }
                     //添加终点坐标
-//                    if (endLatLng != null) {
+                    if (endLatLng != null) {
 //                        points.add(endLatLng);
-//                    }
+                    }
  
                     ArrayList<Integer> traffics = new ArrayList<Integer>();
                     for (int i = 0; i < points.size(); i++) {
@@ -333,7 +335,26 @@ public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
                                 .points(points)
                                 .customTextureList(getCustomTextureList())
                                 .textureIndex(traffics);//设置纹理列表
-                        //在地图上绘制折线
+                        //在地图上绘制起点
+                        if (index == 0) {
+                            //显示当前位置图标
+                            Bitmap pointBitmap = BitmapUtil.getBitmapFromDp(getContext(), BitmapFactory.decodeResource(getContext().getResources(), R.drawable.icon_start), 30, 30);
+                            startMark = new MarkerOptions()
+                                    .position(StartPoint)
+                                    .icon(BitmapDescriptorFactory.fromBitmap(pointBitmap));
+//                            startMark.anchor(0.5f, 0.55f);
+                            baiduMap.addOverlay(startMark);
+                        } else if (index == listSize - 1) {
+                            //显示当前位置图标
+                            Bitmap pointBitmap = BitmapUtil.getBitmapFromDp(getContext(), BitmapFactory.decodeResource(getContext().getResources(), R.drawable.icon_end), 30, 30);
+                            endMark = new MarkerOptions()
+                                    .position(points.get(points.size()-1))
+                                    .icon(BitmapDescriptorFactory.fromBitmap(pointBitmap))
+                                    .perspective(true)
+//                            endMark.anchor(0.5f, 0.5f)
+                            .perspective(true);
+                            baiduMap.addOverlay(endMark);
+                        }
                         //mPloyline 折线对象
                         Overlay mPolyline = baiduMap.addOverlay(mOverlayOptions);
                         MapStatus.Builder builder = new MapStatus.Builder();
@@ -371,8 +392,8 @@ public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
                 if (drivingRouteResult.getRouteLines() != null) {
                     if (drivingRouteResult.getRouteLines().get(0).getAllStep().get(0).getWayPoints().size() > 0) {
                         //添加起点坐标
-                        if (mylocation != null) {
-                            points.add(new LatLng(mylocation.latitude, mylocation.longitude));
+                        if (followMyLocation != null) {
+                            points.add(new LatLng(followMyLocation.latitude, followMyLocation.longitude));
                         }
                         for (int i = 0; i < drivingRouteResult.getRouteLines().get(0).getAllStep().size(); i++) {
                             for (int j = 0; j < drivingRouteResult.getRouteLines().get(0).getAllStep().get(i).getWayPoints().size(); j++) {
@@ -459,12 +480,12 @@ public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
         if (Math.abs(x - lastX) > 1.0) {
             mCurrentDirection = (int) x;
             if (firstLatLng != null) {
-                mylocation = new MyLocationData.Builder()
+                followMyLocation = new MyLocationData.Builder()
                         .accuracy(mCurrentAccracy)
                         // 此处设置开发者获取到的方向信息，顺时针0-360
                         .direction(mCurrentDirection).latitude(firstLatLng.latitude)
                         .longitude(firstLatLng.longitude).build();
-                baiduMap.setMyLocationData(mylocation);
+                baiduMap.setMyLocationData(followMyLocation);
             }
         }
         lastX = x;
@@ -527,12 +548,12 @@ public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
 //            mCurrentLat = location.getLatitude();
 //            mCurrentLon = location.getLongitude();
             mCurrentAccracy = location.getRadius();
-            mylocation = new MyLocationData.Builder()
+            followMyLocation = new MyLocationData.Builder()
                     .accuracy(location.getRadius())
                     // 此处设置开发者获取到的方向信息，顺时针0-360
                     .direction(location.getDirection()).latitude(location.getLatitude())
                     .longitude(location.getLongitude()).build();
-            if (mylocation == null) {
+            if (followMyLocation == null) {
                 return;
             }
  
@@ -542,7 +563,7 @@ public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
                 isFirstLoc = false;
                 firstLatLng = new LatLng(location.getLatitude(),
                         location.getLongitude());
-                baiduMap.setMyLocationData(mylocation);
+                baiduMap.setMyLocationData(followMyLocation);
                 builder.target(firstLatLng).zoom(DEFULT_ZOOM);
                 baiduMap.animateMapStatus(MapStatusUpdateFactory.newMapStatus(builder.build()));
  
@@ -558,13 +579,13 @@ public class RunRaceDetailFragmentView implements MvpView, SensorEventListener {
                             //开始分段规划路径
                             //第一个点
                             if (index == 0) {
-                                searchRouteResult(startLatLng, importLatLngs.get(index), 0);
+                                searchRouteResult(startLatLng, importLatLngs.get(index), 0, importLatLngs.size());
                             } else {
-                                searchRouteResult(importLatLngs.get(index - 1), importLatLngs.get(index), index);
+                                searchRouteResult(importLatLngs.get(index - 1), importLatLngs.get(index), index, importLatLngs.size());
                             }
                         }
                     } else {
-                        searchRouteResult(startLatLng, endLatLng, 0);
+                        searchRouteResult(startLatLng, endLatLng, 0, importLatLngs.size());
                     }
                 }
  
@@ -42,7 +42,7 @@ import org.greenrobot.eventbus.EventBus;
 public class RunningMapFragmentView implements MvpView, SensorEventListener {
     private static final String TAG = "RunningMapFragmentView";
     private RunningMapFragment fragment;
-    private BaiduMap baiduMap;
+    public BaiduMap baiduMap;
     private MapView mMapView;
     private UiSettings mUiSettings;
     private MyLocationConfiguration.LocationMode mCurrentMode;//定位模式
@@ -7,5 +7,4 @@ public class Constant {
     public static final int SERVICE_STEP_COUNT_RESET_SPEED = 3;//重置速度
     public static final int FRAGMENT_RUN_CHRONOMETER = 4;//同步计时器
  
-
 }
@@ -11,6 +11,7 @@ import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
+import android.content.SharedPreferences;
 import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
@@ -23,7 +24,21 @@ import android.os.IBinder;
 import android.support.v4.app.NotificationCompat;
 import android.util.Log;
 import android.widget.RemoteViews;
-
+import android.widget.Toast;
+
+import com.baidu.mapapi.model.LatLng;
+import com.baidu.trace.LBSTraceClient;
+import com.baidu.trace.Trace;
+import com.baidu.trace.api.entity.OnEntityListener;
+import com.baidu.trace.api.fence.FenceAlarmPushInfo;
+import com.baidu.trace.api.fence.MonitoredAction;
+import com.baidu.trace.api.track.LatestPoint;
+import com.baidu.trace.api.track.LatestPointResponse;
+import com.baidu.trace.api.track.OnTrackListener;
+import com.baidu.trace.model.OnTraceListener;
+import com.baidu.trace.model.PushMessage;
+import com.baidu.trace.model.StatusCodes;
+import com.baidu.trace.model.TraceLocation;
 import com.cnlive.moudle.pedometer.model.Constant;
 import com.cnlive.moudle.pedometer.model.MessageEvent;
 import com.cnlive.moudle.pedometer.model.step.StepCount;
@@ -115,6 +130,33 @@ public class StepService extends Service implements SensorEventListener {
     private static int speedCurrentStep;//用于检测速度步数
     private boolean updateSpeedStepFlag;//是否是已经更新速度
  
+    /****************************************************鹰眼轨迹相关************************************************/
+    /**
+     * 轨迹服务监听器
+     */
+    public static OnTraceListener traceListener = null;
+    /**
+     * 轨迹监听器(用于接收纠偏后实时位置回调)
+     */
+    private OnTrackListener realTimeTraceListener = null;
+    //位置采集周期
+    private int gatherInterval = 5;
+    //打包周期
+    private int packInterval = 30;
+    // 轨迹服务ID
+    public static final long serviceId = 213511;
+    // 设备标识
+    public static String entityName = "";
+    /**
+     * 轨迹客户端
+     */
+    public static LBSTraceClient mClient = null;
+
+    /**
+     * 轨迹服务
+     */
+    public Trace mTrace = null;
+
     public StepService() {
  
     }
@@ -125,12 +167,173 @@ public class StepService extends Service implements SensorEventListener {
         Log.e("执行onCreate", "onCreate");
         super.onCreate();
         init();
+        if (mClient == null) {
+            mClient = new LBSTraceClient(getApplicationContext());
+        }
+        if (mTrace == null) {
+            mTrace = new Trace(serviceId, entityName);
+        }
         showStartForegroundNotification();
-        userId = "123";
-        initTodayData(userId);
+
         initBroadcastReceiver();
     }
  
+    private void initTrace() {
+        if (mClient == null) {
+            mClient = new LBSTraceClient(getApplicationContext());
+        }
+        if (mTrace == null) {
+            mTrace = new Trace(serviceId, entityName);
+        }
+        //初始化实时轨迹监听器
+        realTimeTraceListener = new OnTrackListener() {
+
+            @Override
+            public void onLatestPointCallback(LatestPointResponse response) {
+                if (StatusCodes.SUCCESS != response.getStatus()) {
+                    return;
+                }
+
+                LatestPoint point = response.getLatestPoint();
+
+            }
+        };
+
+        //轨迹监听
+        traceListener = new OnTraceListener() {
+
+            /**
+             * 绑定服务回调接口
+             * @param errorNo  状态码
+             * @param message 消息
+             *                <p>
+             *                <pre>0：成功 </pre>
+             *                <pre>1：失败</pre>
+             */
+            @Override
+            public void onBindServiceCallback(int errorNo, String message) {
+            }
+
+            /**
+             * 开启服务回调接口
+             * @param errorNo 状态码
+             * @param message 消息
+             *                <p>
+             *                <pre>0：成功 </pre>
+             *                <pre>10000：请求发送失败</pre>
+             *                <pre>10001：服务开启失败</pre>
+             *                <pre>10002：参数错误</pre>
+             *                <pre>10003：网络连接失败</pre>
+             *                <pre>10004：网络未开启</pre>
+             *                <pre>10005：服务正在开启</pre>
+             *                <pre>10006：服务已开启</pre>
+             */
+            @Override
+            public void onStartTraceCallback(int errorNo, String message) {
+                if (StatusCodes.SUCCESS == errorNo || StatusCodes.START_TRACE_NETWORK_CONNECT_FAILED <= errorNo) {
+                    //开始进行采集
+                    if (mClient != null) {
+                        mClient.startGather(traceListener);
+                        Toast.makeText(getApplicationContext(), "开启轨迹服务", Toast.LENGTH_LONG).show();
+
+                    }
+                }
+            }
+
+            /**
+             * 停止服务回调接口
+             * @param errorNo 状态码
+             * @param message 消息
+             *                <p>
+             *                <pre>0：成功</pre>
+             *                <pre>11000：请求发送失败</pre>
+             *                <pre>11001：服务停止失败</pre>
+             *                <pre>11002：服务未开启</pre>
+             *                <pre>11003：服务正在停止</pre>
+             */
+            @Override
+            public void onStopTraceCallback(int errorNo, String message) {
+                if (StatusCodes.SUCCESS == errorNo || StatusCodes.CACHE_TRACK_NOT_UPLOAD == errorNo) {
+                    if (mClient != null) {
+                        mClient.stopTrace(mTrace, traceListener);
+                        Toast.makeText(getApplicationContext(), "停止轨迹服务", Toast.LENGTH_LONG).show();
+
+                    }
+                }
+            }
+
+            /**
+             * 开启采集回调接口
+             * @param errorNo 状态码
+             * @param message 消息
+             *                <p>
+             *                <pre>0：成功</pre>
+             *                <pre>12000：请求发送失败</pre>
+             *                <pre>12001：采集开启失败</pre>
+             *                <pre>12002：服务未开启</pre>
+             */
+            @Override
+            public void onStartGatherCallback(int errorNo, String message) {
+                if (StatusCodes.SUCCESS == errorNo || StatusCodes.GATHER_STARTED == errorNo) {
+                    Toast.makeText(getApplicationContext(), "开始采集", Toast.LENGTH_LONG).show();
+                }
+            }
+
+            /**
+             * 停止采集回调接口
+             * @param errorNo 状态码
+             * @param message 消息
+             *                <p>
+             *                <pre>0：成功</pre>
+             *                <pre>13000：请求发送失败</pre>
+             *                <pre>13001：采集停止失败</pre>
+             *                <pre>13002：服务未开启</pre>
+             */
+            @Override
+            public void onStopGatherCallback(int errorNo, String message) {
+                if (StatusCodes.SUCCESS == errorNo || StatusCodes.GATHER_STOPPED == errorNo) {
+                    Toast.makeText(getApplicationContext(), "停止采集", Toast.LENGTH_LONG).show();
+                    if (mClient != null) {
+                        mClient.stopTrace(mTrace, traceListener);
+                    }
+                }
+            }
+
+            /**
+             * 推送消息回调接口
+             *
+             * @param messageType 状态码
+             * @param pushMessage 消息
+             *                  <p>
+             *                  <pre>0x01：配置下发</pre>
+             *                  <pre>0x02：语音消息</pre>
+             *                  <pre>0x03：服务端围栏报警消息</pre>
+             *                  <pre>0x04：本地围栏报警消息</pre>
+             *                  <pre>0x05~0x40：系统预留</pre>
+             *                  <pre>0x41~0xFF：开发者自定义</pre>
+             */
+            @Override
+            public void onPushCallback(byte messageType, PushMessage pushMessage) {
+                if (messageType < 0x03 || messageType > 0x04) {
+                    return;
+                }
+                FenceAlarmPushInfo alarmPushInfo = pushMessage.getFenceAlarmPushInfo();
+                if (null == alarmPushInfo) {
+                    return;
+                }
+            }
+
+            @Override
+            public void onInitBOSCallback(int errorNo, String message) {
+            }
+        };
+
+        //开启轨迹服务
+        if (mClient != null) {
+            mClient.startTrace(mTrace, traceListener);
+        }
+
+    }
  
     private long i = 0;
     private long index = 0;
@@ -142,6 +345,9 @@ public class StepService extends Service implements SensorEventListener {
     public int onStartCommand(Intent intent, int flags, int startId) {
         if (intent.getExtras().getString("userId") != null) {
             userId = intent.getExtras().getString("userId");
+            entityName = userId;
+            initTodayData(userId);
+            initTrace();
             if (!EventBus.getDefault().isRegistered(this)) {
                 EventBus.getDefault().register(this);
             }
@@ -308,9 +514,14 @@ public class StepService extends Service implements SensorEventListener {
      */
     private void initTodayData(String userId) {
         CURRENT_DATE = getTodayDate();
-
+        if (userId == null || CURRENT_DATE == null) {
+            return;
+        }
 //        //获取当天的数据，用于展示 CURRENT_DATE
         List<UserStepEntity> list = DbCore.getDaoSession().getUserStepEntityDao().queryBuilder().where(UserStepEntityDao.Properties.UserId.eq(userId), UserStepEntityDao.Properties.Date.eq(CURRENT_DATE)).list();
+        if (list == null) {
+            return;
+        }
         if (list.size() == 0 || list.isEmpty()) {
             CURRENT_STEP = 0;
         } else if (list.size() == 1) {
@@ -765,4 +976,6 @@ public class StepService extends Service implements SensorEventListener {
         int h = (int) (time / 3600) % 60;//小时
         return String.format("%02d:%02d:%02d", h, m, s);
     }
+
+
 }
@@ -4,6 +4,7 @@ import android.hardware.Sensor;
 import android.hardware.SensorManager;
 import android.os.Bundle;
 import android.support.annotation.Nullable;
+import android.text.TextUtils;
 import android.util.Log;
 import android.view.View;
  
@@ -14,6 +15,8 @@ import com.cnlive.moudle.pedometer.frame.view.RunningMapFragmentView;
 import com.cnlive.moudle.pedometer.model.RunningMapBean;
 import com.cnlive.moudle.pedometer.model.Constant;
 import com.cnlive.moudle.pedometer.model.MessageEvent;
+import com.cnlive.moudle.pedometer.service.StepService;
+import com.cnlive.moudle.pedometer.utils.TimeUtil;
 import com.example.moudle_pedometer.R;
 import com.example.moudle_pedometer.databinding.FragmentRunningMapBinding;
  
@@ -78,6 +81,12 @@ public class RunningMapFragment extends QMUIFragment&lt;RunningMapFragmentView, Run
                 getMvpView().updateChronometer(runningMapBean);
             }
         }
+        //开始进行历史轨迹查询
+        if (getPresenter() != null && !TextUtils.isEmpty(StepService.entityName)) {
+            long startTime = runningMapBean.getTimeBase();
+            long endTime = TimeUtil.getCurrentTime();
+            getPresenter().queryHistoryTrace(getActivity(), StepService.entityName, startTime, endTime);
+        }
     }
  
     @Override
@@ -41,6 +41,17 @@ public class ButtonAnimUtil {
         animatorSetsuofang.start();
     }
  
+    //设置控件缩小动画
+    public static void setViewDefault(View view) {
+        AnimatorSet animatorSetsuofang = new AnimatorSet();//组合动画
+        ObjectAnimator scaleX = ObjectAnimator.ofFloat(view, "scaleX", 1f, 1);
+        ObjectAnimator scaleY = ObjectAnimator.ofFloat(view, "scaleY", 1f, 1);
+        animatorSetsuofang.setDuration(DEFAULT_ZOOM_DURATION);
+        animatorSetsuofang.setInterpolator(new DecelerateInterpolator());
+        animatorSetsuofang.play(scaleX).with(scaleY);//两个动画同时开始
+        animatorSetsuofang.start();
+    }
+
     //设置控件显示放大动画
     public static void setViewShowZoomIn(View view) {
         AnimatorSet animatorSetsuofang = new AnimatorSet();//组合动画
+package com.cnlive.moudle.pedometer.utils;
+
+import android.app.ActivityManager;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.telephony.TelephonyManager;
+
+import com.baidu.mapapi.model.LatLng;
+
+import java.sql.Timestamp;
+import java.text.DecimalFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+
+/**
+ * Created by baidu on 17/1/23.
+ */
+
+public class CommonUtil {
+
+    private static DecimalFormat df = new DecimalFormat("######0.00");
+
+    public static final double DISTANCE = 0.0001;
+
+    public static String getCurProcessName(Context context) {
+        int pid = android.os.Process.myPid();
+        ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+        for (ActivityManager.RunningAppProcessInfo appProcess : activityManager.getRunningAppProcesses()) {
+            if (appProcess.pid == pid) {
+                return appProcess.processName;
+            }
+        }
+        return "";
+    }
+
+    /**
+     * 获取当前时间戳(单位：秒)
+     *
+     * @return
+     */
+    public static long getCurrentTime() {
+        return System.currentTimeMillis() / 1000;
+    }
+
+    /**
+     * 校验double数值是否为0
+     *
+     * @param value
+     *
+     * @return
+     */
+    public static boolean isEqualToZero(double value) {
+        return Math.abs(value - 0.0) < 0.01 ? true : false;
+    }
+
+    /**
+     * 经纬度是否为(0,0)点
+     *
+     * @return
+     */
+    public static boolean isZeroPoint(double latitude, double longitude) {
+        return isEqualToZero(latitude) && isEqualToZero(longitude);
+    }
+
+    /**
+     * 将字符串转为时间戳
+     */
+    public static long toTimeStamp(String time) {
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",
+                Locale.CHINA);
+        Date date;
+        try {
+            date = sdf.parse(time);
+        } catch (ParseException e) {
+            e.printStackTrace();
+            return 0;
+        }
+        return date.getTime() / 1000;
+    }
+
+    /**
+     * 获取时分秒
+     *
+     * @param timestamp 时间戳（单位：毫秒）
+     *
+     * @return
+     */
+    public static String getHMS(long timestamp) {
+        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
+        try {
+            return sdf.format(new Timestamp(timestamp));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return String.valueOf(timestamp);
+    }
+
+    /**
+     * 获取年月日 时分秒
+     *
+     * @param timestamp 时间戳（单位：毫秒）
+     *
+     * @return
+     */
+    public static String formatTime(long timestamp) {
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        try {
+            return sdf.format(new Timestamp(timestamp));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return String.valueOf(timestamp);
+    }
+
+    public static String formatSecond(int second) {
+        String format = "%1$,02d:%2$,02d:%3$,02d";
+        Integer hours = second / (60 * 60);
+        Integer minutes = second / 60 - hours * 60;
+        Integer seconds = second - minutes * 60 - hours * 60 * 60;
+        Object[] array = new Object[] {hours, minutes, seconds};
+        return String.format(format, array);
+    }
+
+    public static final String formatDouble(double doubleValue) {
+        return df.format(doubleValue);
+    }
+
+    /**
+     * 计算x方向每次移动的距离
+     */
+    public static double getXMoveDistance(double slope) {
+        if (slope == Double.MAX_VALUE) {
+            return DISTANCE;
+        }
+        return Math.abs((DISTANCE * slope) / Math.sqrt(1 + slope * slope));
+    }
+
+    /**
+     * 根据点和斜率算取截距
+     */
+    public static double getInterception(double slope, LatLng point) {
+        return point.latitude - slope * point.longitude;
+    }
+
+    /**
+     * 算斜率
+     */
+    public static double getSlope(LatLng fromPoint, LatLng toPoint) {
+        if (toPoint.longitude == fromPoint.longitude) {
+            return Double.MAX_VALUE;
+        }
+        return (toPoint.latitude - fromPoint.latitude) / (toPoint.longitude - fromPoint.longitude);
+    }
+
+    /**
+     * 根据两点算取图标转的角度
+     */
+    public static double getAngle(LatLng fromPoint, LatLng toPoint) {
+        double slope = getSlope(fromPoint, toPoint);
+        if (slope == Double.MAX_VALUE) {
+            if (toPoint.latitude > fromPoint.latitude) {
+                return 0;
+            } else {
+                return 180;
+            }
+        }
+        float deltAngle = 0;
+        if ((toPoint.latitude - fromPoint.latitude) * slope < 0) {
+            deltAngle = 180;
+        }
+        double radio = Math.atan(slope);
+        return 180 * (radio / Math.PI) + deltAngle - 90;
+    }
+
+    /**
+     * 保存当前定位点
+     */
+//    public static void saveCurrentLocation(TrackApplication trackApp) {
+//        SharedPreferences.Editor editor = trackApp.trackConf.edit();
+//        StringBuffer locationInfo = new StringBuffer();
+//        locationInfo.append(CurrentLocation.locTime);
+//        locationInfo.append(";");
+//        locationInfo.append(CurrentLocation.latitude);
+//        locationInfo.append(";");
+//        locationInfo.append(CurrentLocation.longitude);
+//        editor.putString(Constants.LAST_LOCATION, locationInfo.toString());
+//        editor.apply();
+//    }
+
+    /**
+     * 获取设备IMEI码
+     *
+     * @param context
+     *
+     * @return
+     */
+    public static String getImei(Context context) {
+        String imei;
+        try {
+            imei = ((TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE)).getDeviceId();
+        } catch (Exception e) {
+            imei = "myTrace";
+        }
+        return imei;
+    }
+
+}
+package com.cnlive.moudle.pedometer.utils;
+
+import android.graphics.Color;
+import android.graphics.Point;
+import android.os.Bundle;
+import android.text.TextUtils;
+
+import com.baidu.mapapi.map.BaiduMap;
+import com.baidu.mapapi.map.BitmapDescriptor;
+import com.baidu.mapapi.map.MapStatus;
+import com.baidu.mapapi.map.MapStatusUpdate;
+import com.baidu.mapapi.map.MapStatusUpdateFactory;
+import com.baidu.mapapi.map.MapView;
+import com.baidu.mapapi.map.Marker;
+import com.baidu.mapapi.map.MarkerOptions;
+import com.baidu.mapapi.map.Overlay;
+import com.baidu.mapapi.map.OverlayOptions;
+import com.baidu.mapapi.map.PolylineOptions;
+import com.baidu.mapapi.model.LatLng;
+import com.baidu.mapapi.model.LatLngBounds;
+import com.baidu.mapapi.utils.CoordinateConverter;
+import com.baidu.trace.model.CoordType;
+import com.baidu.trace.model.SortType;
+import com.baidu.trace.model.TraceLocation;
+
+import java.util.List;
+
+
+/**
+ * Created by baidu on 17/2/9.
+ */
+
+public class MapUtil {
+
+    private static MapUtil INSTANCE = new MapUtil();
+
+    private MapStatus mapStatus = null;
+
+    private Marker mMoveMarker = null;
+
+    public MapView mapView = null;
+
+    public BaiduMap baiduMap = null;
+
+    public LatLng lastPoint = null;
+
+    /**
+     * 路线覆盖物
+     */
+    public Overlay polylineOverlay = null;
+
+    private MapUtil() {
+    }
+
+    public static MapUtil getInstance() {
+        return INSTANCE;
+    }
+
+    public void init(MapView view) {
+        mapView = view;
+        baiduMap = mapView.getMap();
+        mapView.showZoomControls(false);
+    }
+
+    public void onPause() {
+        if (null != mapView) {
+            mapView.onPause();
+        }
+    }
+
+    public void onResume() {
+        if (null != mapView) {
+            mapView.onResume();
+        }
+    }
+
+    public void clear() {
+        lastPoint = null;
+        if (null != mMoveMarker) {
+            mMoveMarker.remove();
+            mMoveMarker = null;
+        }
+        if (null != polylineOverlay) {
+            polylineOverlay.remove();
+            polylineOverlay = null;
+        }
+        if (null != baiduMap) {
+            baiduMap.clear();
+            baiduMap = null;
+        }
+        mapStatus = null;
+        if (null != mapView) {
+            mapView.onDestroy();
+            mapView = null;
+        }
+    }
+
+    /**
+     * 将轨迹实时定位点转换为地图坐标
+     *
+     * @param location
+     *
+     * @return
+     */
+    public static LatLng convertTraceLocation2Map(TraceLocation location) {
+        if (null == location) {
+            return null;
+        }
+        double latitude = location.getLatitude();
+        double longitude = location.getLongitude();
+        if (Math.abs(latitude - 0.0) < 0.000001 && Math.abs(longitude - 0.0) < 0.000001) {
+            return null;
+        }
+        LatLng currentLatLng = new LatLng(latitude, longitude);
+        if (CoordType.wgs84 == location.getCoordType()) {
+            LatLng sourceLatLng = currentLatLng;
+            CoordinateConverter converter = new CoordinateConverter();
+            converter.from(CoordinateConverter.CoordType.GPS);
+            converter.coord(sourceLatLng);
+            currentLatLng = converter.convert();
+        }
+        return currentLatLng;
+    }
+
+    /**
+     * 将地图坐标转换轨迹坐标
+     *
+     * @param latLng
+     *
+     * @return
+     */
+    public static com.baidu.trace.model.LatLng convertMap2Trace(LatLng latLng) {
+        return new com.baidu.trace.model.LatLng(latLng.latitude, latLng.longitude);
+    }
+
+    /**
+     * 将轨迹坐标对象转换为地图坐标对象
+     *
+     * @param traceLatLng
+     *
+     * @return
+     */
+    public static LatLng convertTrace2Map(com.baidu.trace.model.LatLng traceLatLng) {
+        return new LatLng(traceLatLng.latitude, traceLatLng.longitude);
+    }
+
+//    /**
+//     * 设置地图中心：使用已有定位信息；
+//     *
+//     * @param trackApp
+//     */
+//    public void setCenter(TrackApplication trackApp) {
+//        if (!CommonUtil.isZeroPoint(CurrentLocation.latitude, CurrentLocation.longitude)) {
+//            LatLng currentLatLng = new LatLng(CurrentLocation.latitude, CurrentLocation.longitude);
+//            updateStatus(currentLatLng, false);
+//            return;
+//        }
+//        String lastLocation = trackApp.trackConf.getString(Constants.LAST_LOCATION, null);
+//        if (!TextUtils.isEmpty(lastLocation)) {
+//            String[] locationInfo = lastLocation.split(";");
+//            if (!CommonUtil.isZeroPoint(Double.parseDouble(locationInfo[1]),
+//                    Double.parseDouble(locationInfo[2]))) {
+//                LatLng currentLatLng = new LatLng(Double.parseDouble(locationInfo[1]),
+//                        Double.parseDouble(locationInfo[2]));
+//                updateStatus(currentLatLng, false);
+//                return;
+//            }
+//        }
+//    }
+
+//    public void updateStatus(LatLng currentPoint, boolean showMarker) {
+//        if (null == baiduMap || null == currentPoint) {
+//            return;
+//        }
+//
+//        if (null != baiduMap.getProjection()) {
+//            Point screenPoint = baiduMap.getProjection().toScreenLocation(currentPoint);
+//            // 点在屏幕上的坐标超过限制范围，则重新聚焦底图
+//            if (screenPoint.y < 200 || screenPoint.y > TrackApplication.screenHeight - 500
+//                    || screenPoint.x < 200 || screenPoint.x > TrackApplication.screenWidth - 200
+//                    || null == mapStatus) {
+//                animateMapStatus(currentPoint, 15.0f);
+//            }
+//        } else if (null == mapStatus) {
+//            // 第一次定位时，聚焦底图
+//            setMapStatus(currentPoint, 15.0f);
+//        }
+//
+//        if (showMarker) {
+//            addMarker(currentPoint);
+//        }
+//
+//    }
+
+    public Marker addOverlay(LatLng currentPoint, BitmapDescriptor icon, Bundle bundle) {
+        OverlayOptions overlayOptions = new MarkerOptions().position(currentPoint)
+                .icon(icon).zIndex(9).draggable(true);
+        Marker marker = (Marker) baiduMap.addOverlay(overlayOptions);
+        if (null != bundle) {
+            marker.setExtraInfo(bundle);
+        }
+        return marker;
+    }
+
+    /**
+     * 添加地图覆盖物
+     */
+//    public void addMarker(LatLng currentPoint) {
+//        if (null == mMoveMarker) {
+//            mMoveMarker = addOverlay(currentPoint, BitmapUtil.bmArrowPoint, null);
+//            return;
+//        }
+//
+//        if (null != lastPoint) {
+//            moveLooper(currentPoint);
+//        } else {
+//            lastPoint = currentPoint;
+//            mMoveMarker.setPosition(currentPoint);
+//        }
+//    }
+
+    /**
+     * 移动逻辑
+     */
+    public void moveLooper(LatLng endPoint) {
+
+        mMoveMarker.setPosition(lastPoint);
+        mMoveMarker.setRotate((float) CommonUtil.getAngle(lastPoint, endPoint));
+
+        double slope = CommonUtil.getSlope(lastPoint, endPoint);
+        // 是不是正向的标示（向上设为正向）
+        boolean isReverse = (lastPoint.latitude > endPoint.latitude);
+        double intercept = CommonUtil.getInterception(slope, lastPoint);
+        double xMoveDistance = isReverse ? CommonUtil.getXMoveDistance(slope) : -1 * CommonUtil.getXMoveDistance(slope);
+
+        for (double latitude = lastPoint.latitude; latitude > endPoint.latitude == isReverse; latitude =
+                latitude - xMoveDistance) {
+            LatLng latLng;
+            if (slope != Double.MAX_VALUE) {
+                latLng = new LatLng(latitude, (latitude - intercept) / slope);
+            } else {
+                latLng = new LatLng(latitude, lastPoint.longitude);
+            }
+            mMoveMarker.setPosition(latLng);
+        }
+    }
+
+
+    public void animateMapStatus(List<LatLng> points) {
+        if (null == points || points.isEmpty()) {
+            return;
+        }
+        LatLngBounds.Builder builder = new LatLngBounds.Builder();
+        for (LatLng point : points) {
+            builder.include(point);
+        }
+        MapStatusUpdate msUpdate = MapStatusUpdateFactory.newLatLngBounds(builder.build());
+        baiduMap.animateMapStatus(msUpdate);
+    }
+
+    public void animateMapStatus(LatLng point, float zoom) {
+        MapStatus.Builder builder = new MapStatus.Builder();
+        mapStatus = builder.target(point).zoom(zoom).build();
+        baiduMap.animateMapStatus(MapStatusUpdateFactory.newMapStatus(mapStatus));
+    }
+
+    public void setMapStatus(LatLng point, float zoom) {
+        MapStatus.Builder builder = new MapStatus.Builder();
+        mapStatus = builder.target(point).zoom(zoom).build();
+        baiduMap.setMapStatus(MapStatusUpdateFactory.newMapStatus(mapStatus));
+    }
+
+    public void refresh() {
+        LatLng mapCenter = baiduMap.getMapStatus().target;
+        float mapZoom = baiduMap.getMapStatus().zoom - 1.0f;
+        setMapStatus(mapCenter, mapZoom);
+    }
+
+}
+
+package com.cnlive.moudle.pedometer.utils;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Color;
+
+import com.baidu.mapapi.map.BaiduMap;
+import com.baidu.mapapi.map.BitmapDescriptorFactory;
+import com.baidu.mapapi.map.Marker;
+import com.baidu.mapapi.map.MarkerOptions;
+import com.baidu.mapapi.map.Overlay;
+import com.baidu.mapapi.map.OverlayOptions;
+import com.baidu.mapapi.map.PolylineOptions;
+import com.baidu.mapapi.model.LatLng;
+import com.baidu.trace.model.SortType;
+import com.example.moudle_pedometer.R;
+
+import java.util.List;
+
+/**
+ * @author ShinnyYang
+ */
+public class MyMapUtil {
+    /**
+     * 将轨迹坐标对象转换为地图坐标对象
+     *
+     * @param traceLatLng
+     * @return
+     */
+    public static LatLng convertTrace2Map(com.baidu.trace.model.LatLng traceLatLng) {
+        return new LatLng(traceLatLng.latitude, traceLatLng.longitude);
+    }
+
+    /**
+     * 绘制历史轨迹
+     */
+    public static Overlay drawHistoryTrack(Context context, BaiduMap baiduMap, List<LatLng> points, SortType sortType, int lineColor, int startIconRes, int endIconRes) {
+        // 绘制新覆盖物前，清空之前的覆盖物
+        baiduMap.clear();
+        if (points == null || points.size() == 0) {
+            return null;
+        }
+        //只有一个点
+        if (points.size() == 1) {
+            Bitmap pointBitmap = BitmapUtil.getBitmapFromDp(context, BitmapFactory.decodeResource(context.getResources(), startIconRes), 40, 40);
+            OverlayOptions startOptions = new MarkerOptions().position(points.get(0)).icon(BitmapDescriptorFactory.fromBitmap(pointBitmap));
+//                    .zIndex(9).draggable(true);
+            return baiduMap.addOverlay(startOptions);
+        }
+
+        LatLng startPoint;
+        LatLng endPoint;
+        if (sortType == SortType.asc) {
+            startPoint = points.get(0);
+            endPoint = points.get(points.size() - 1);
+        } else {
+            startPoint = points.get(points.size() - 1);
+            endPoint = points.get(0);
+        }
+
+        // 添加起点图标
+        Bitmap startPointBitmap = BitmapUtil.getBitmapFromDp(context, BitmapFactory.decodeResource(context.getResources(), startIconRes), 40, 40);
+        OverlayOptions startOptions = new MarkerOptions()
+                .position(startPoint).icon(BitmapDescriptorFactory.fromBitmap(startPointBitmap));
+//                .zIndex(9).draggable(true);
+        // 添加终点图标
+        Bitmap endPointBitmap = BitmapUtil.getBitmapFromDp(context, BitmapFactory.decodeResource(context.getResources(), endIconRes), 40, 40);
+        OverlayOptions endOptions = new MarkerOptions().position(endPoint)
+                .icon(BitmapDescriptorFactory.fromBitmap(endPointBitmap));
+//                .zIndex(9).draggable(true);
+
+        // 添加路线（轨迹）
+        OverlayOptions polylineOptions = new PolylineOptions().width(10)
+                .color(context.getResources().getColor(lineColor)).points(points);
+
+        baiduMap.addOverlay(startOptions);
+//        baiduMap.addOverlay(endOptions);
+        return baiduMap.addOverlay(polylineOptions);
+    }
+}
+package com.cnlive.moudle.pedometer.utils;
+
+public class TimeUtil {
+    /**
+     * 获取当前时间戳(单位：秒)
+     *
+     * @return
+     */
+    public static long getCurrentTime() {
+        return System.currentTimeMillis() / 1000;
+    }
+
+}