1.赛事详情

杨帅
1 parent f478a583
Showing 6 changed files with 285 additions and 17 deletions
library_baidumap/src/main/AndroidManifest.xml
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/frame/presenter/RunningMapFragmentPresenter.java
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/frame/view/RunningMapFragmentView.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
moudle_pedometer/src/main/java/com/cnlive/moudle/pedometer/utils/MyMapUtil.java
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
     package="com.example.moudle_baidumap">
  
     <uses-permission android:name="com.android.launcher.permission.READ_SETTINGS" />
@@ -19,6 +20,16 @@
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
     <!-- 访问网络，网络定位需要上网 -->
     <uses-permission android:name="android.permission.INTERNET" />
+    <!-- 这个权限用于获取wifi的获取权限，wifi信息会用来进行网络定位-->
+    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"></uses-permission>
+    <!-- SD卡读取权限，用于写入对象存储BOS数据-->
+    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"
+        tools:ignore="ProtectedPermissions"></uses-permission>
+    <!-- 用于加快GPS首次定位-->
+    <uses-permission android:name="android.permission.ACCESS_LOCATION_EXTRA_COMMANDS"></uses-permission>
+    <!-- 用于Android M及以上系统，申请加入忽略电池优化白名单-->
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"></uses-permission>
+
     <application>
         <service
             android:name="com.baidu.location.f"
@@ -8,10 +8,23 @@ import android.widget.Toast;
  
 import com.baidu.mapapi.map.BitmapDescriptorFactory;
 import com.baidu.mapapi.map.MarkerOptions;
+import com.baidu.mapapi.map.Overlay;
 import com.baidu.mapapi.map.OverlayOptions;
 import com.baidu.mapapi.model.LatLng;
+import com.baidu.trace.api.entity.AddEntityResponse;
+import com.baidu.trace.api.entity.AroundSearchResponse;
+import com.baidu.trace.api.entity.BoundSearchResponse;
+import com.baidu.trace.api.entity.DeleteEntityResponse;
+import com.baidu.trace.api.entity.DistrictSearchResponse;
+import com.baidu.trace.api.entity.EntityInfo;
+import com.baidu.trace.api.entity.EntityListRequest;
 import com.baidu.trace.api.entity.EntityListResponse;
+import com.baidu.trace.api.entity.FilterCondition;
+import com.baidu.trace.api.entity.LocRequest;
 import com.baidu.trace.api.entity.OnEntityListener;
+import com.baidu.trace.api.entity.PolygonSearchResponse;
+import com.baidu.trace.api.entity.SearchResponse;
+import com.baidu.trace.api.entity.SortBy;
 import com.baidu.trace.api.entity.UpdateEntityResponse;
 import com.baidu.trace.api.track.HistoryTrackRequest;
 import com.baidu.trace.api.track.HistoryTrackResponse;
@@ -45,14 +58,23 @@ public class RunningMapFragmentPresenter extends MvpBasePresenter&lt;RunningMapFrag
     private int pageSize = 1000;
     //分页索引
     private int pageIndex = 1;
+    //分页大小
+    private int realTimePageSize = 1000;
+    //分页索引
+    private int realTimePageIndex = 1;
     /**
      * 历史轨迹请求
      */
     private HistoryTrackRequest historyTrackRequest;
     /**
+     * 实时轨迹请求
+     */
+    private LocRequest realTimeListRequest;
+    /**
      * 轨迹点集合
      */
     private List<LatLng> trackPoints;
+    private List<LatLng> realTimePoints;
  
     /**
      * 查询历史轨迹
@@ -86,11 +108,11 @@ public class RunningMapFragmentPresenter extends MvpBasePresenter&lt;RunningMapFrag
             //绑路：设置是否将轨迹点绑定至路网道路
             processOption.setNeedMapMatch(false);
             //抽稀：设置是否进行抽稀处理，对冗余的轨迹点进行抽稀去除处理，如一条直线上除起终点外的多个轨迹点
-            processOption.setNeedVacuate(true);
+//            processOption.setNeedVacuate(true);
             //自动判断交通方式
             processOption.setTransportMode(TransportMode.walking);
             // 设置精度过滤值(定位精度大于100米的过滤掉)
-            processOption.setRadiusThreshold(20);
+            processOption.setRadiusThreshold(9);
             // 设置纠偏选项
             historyTrackRequest.setProcessOption(processOption);
             // 设置里程填充方式为驾车
@@ -159,4 +181,98 @@ public class RunningMapFragmentPresenter extends MvpBasePresenter&lt;RunningMapFrag
  
     }
  
+
+    public void queryRealTimeTrace(Context context, String entityName, long activeTime) {
+        if (realTimeListRequest == null) {
+            List<String> names = new ArrayList<>();
+            names.add(entityName);
+            realTimeListRequest = new LocRequest();
+            realTimeListRequest.setServiceId(StepService.serviceId);
+            realTimeListRequest.setTag(1);
+        }
+        if (realTimePoints == null) {
+            realTimePoints = new ArrayList<>();
+        }
+
+        OnEntityListener onEntityListener = new OnEntityListener() {
+            Overlay realTimeOverlay = null;
+
+            @Override
+            public void onEntityListCallback(EntityListResponse entityListResponse) {
+                super.onEntityListCallback(entityListResponse);
+                Log.e(TAG, "onEntityListCallback");
+                Toast.makeText(context, "onEntityListCallback", Toast.LENGTH_SHORT).show();
+            }
+
+            @Override
+            public void onSearchEntityCallback(SearchResponse searchResponse) {
+                super.onSearchEntityCallback(searchResponse);
+                Log.e(TAG, "onSearchEntityCallback");
+                Toast.makeText(context, "onSearchEntityCallback", Toast.LENGTH_SHORT).show();
+
+            }
+
+            @Override
+            public void onBoundSearchCallback(BoundSearchResponse boundSearchResponse) {
+                super.onBoundSearchCallback(boundSearchResponse);
+                Log.e(TAG, "onBoundSearchCallback");
+                Toast.makeText(context, "onBoundSearchCallback", Toast.LENGTH_SHORT).show();
+
+            }
+
+            @Override
+            public void onAroundSearchCallback(AroundSearchResponse aroundSearchResponse) {
+                super.onAroundSearchCallback(aroundSearchResponse);
+                Log.e(TAG, "onAroundSearchCallback");
+                Toast.makeText(context, "onAroundSearchCallback", Toast.LENGTH_SHORT).show();
+
+            }
+
+            @Override
+            public void onPolygonSearchCallback(PolygonSearchResponse polygonSearchResponse) {
+                super.onPolygonSearchCallback(polygonSearchResponse);
+                Log.e(TAG, "onPolygonSearchCallback");
+                Toast.makeText(context, "onPolygonSearchCallback", Toast.LENGTH_SHORT).show();
+            }
+
+            @Override
+            public void onDistrictSearchCallback(DistrictSearchResponse districtSearchResponse) {
+                super.onDistrictSearchCallback(districtSearchResponse);
+                Log.e(TAG, "onDistrictSearchCallback");
+                Toast.makeText(context, "onDistrictSearchCallback", Toast.LENGTH_SHORT).show();
+
+            }
+
+            /**实时定位回调接口
+             * @param traceLocation
+             */
+            @Override
+            public void onReceiveLocation(TraceLocation traceLocation) {
+                super.onReceiveLocation(traceLocation);
+                Log.e(TAG, "onReceiveLocation");
+                Toast.makeText(context, "onReceiveLocation", Toast.LENGTH_SHORT).show();
+
+                Log.e(TAG, "onReceiveLocation");
+                if (traceLocation != null) {
+                    realTimePoints.add(new LatLng(traceLocation.getLatitude(), traceLocation.getLongitude()));
+                }
+                if (realTimePoints.size() > 2) {
+                    if (getView() != null) {
+                        if (realTimeOverlay == null) {
+                            realTimeOverlay = MyMapUtil.drawMapLine(context, getView().baiduMap, realTimePoints, R.color.black);
+                        } else {
+                            realTimeOverlay.remove();
+                            realTimeOverlay = MyMapUtil.drawMapLine(context, getView().baiduMap, realTimePoints, R.color.black);
+
+                        }
+                    }
+                }
+            }
+        };
+        //查询实时轨迹
+        if (StepService.mClient != null) {
+            StepService.mClient.queryRealTimeLoc(realTimeListRequest, onEntityListener);
+        }
+
+    }
 }
@@ -80,7 +80,7 @@ public class RunningMapFragmentView implements MvpView, SensorEventListener {
             mUiSettings = baiduMap.getUiSettings();
         }
         //设置定位模式, 默认为 LocationMode.NORMAL 普通态
-        mCurrentMode = MyLocationConfiguration.LocationMode.NORMAL;
+        mCurrentMode = MyLocationConfiguration.LocationMode.FOLLOWING;
         // 设置定位图标修改为自定义marker
         Bitmap pointBitmap = BitmapUtil.getBitmapFromDp(getContext(), BitmapFactory.decodeResource(getContext().getResources(), R.drawable.rt_ic_location), 40, 40);
         mCurrentMarker = BitmapDescriptorFactory.fromBitmap(pointBitmap);
@@ -173,7 +173,7 @@ public class RunningMapFragmentView implements MvpView, SensorEventListener {
             mylocation = new MyLocationData.Builder()
                     .accuracy(location.getRadius())
                     // 此处设置开发者获取到的方向信息，顺时针0-360
-                    .direction(location.getDirection()).latitude(location.getLatitude())
+                    .direction(mCurrentDirection).latitude(location.getLatitude())
                     .longitude(location.getLongitude()).build();
             if (mylocation == null) {
                 return;
@@ -181,20 +181,27 @@ public class RunningMapFragmentView implements MvpView, SensorEventListener {
  
             MapStatus.Builder builder = new MapStatus.Builder();
  
-            if (isFirstLoc) {
-                isFirstLoc = false;
-                firstLatLng = new LatLng(location.getLatitude(),
-                        location.getLongitude());
-                baiduMap.setMyLocationData(mylocation);
-                builder.target(firstLatLng).zoom(DEFULT_ZOOM);
-                baiduMap.animateMapStatus(MapStatusUpdateFactory.newMapStatus(builder.build()));
+//            if (isFirstLoc) {
+//                isFirstLoc = false;
+            firstLatLng = new LatLng(location.getLatitude(),
+                    location.getLongitude());
+            baiduMap.setMyLocationData(mylocation);
+//            if (isFirstLoc) {
+//                builder.target(firstLatLng).zoom(DEFULT_ZOOM);
+//                isFirstLoc = false;
+//            } else {
+//                float current = baiduMap.getMapStatus().zoom;
+//                builder.target(firstLatLng).zoom(current);
+//
+//            }
+//            baiduMap.animateMapStatus(MapStatusUpdateFactory.newMapStatus(builder.build()));
 //                //显示当前位置图标
 //                Bitmap pointBitmap = BitmapUtil.getBitmapFromDp(getContext(), BitmapFactory.decodeResource(getContext().getResources(), R.drawable.rt_ic_location), 40, 40);
 //                currentMark = new MarkerOptions().position(firstLatLng).icon(BitmapDescriptorFactory.fromBitmap(pointBitmap));
 //                baiduMap.addOverlay(currentMark);
  
  
-            }
+//            }
         }
     }
  
@@ -267,12 +274,12 @@ public class RunningMapFragmentView implements MvpView, SensorEventListener {
         double x = sensorEvent.values[SensorManager.DATA_X];
         if (Math.abs(x - lastX) > 1.0) {
             mCurrentDirection = (int) x;
-            if (firstLatLng != null) {
+            if (mylocation != null) {
                 mylocation = new MyLocationData.Builder()
                         .accuracy(mCurrentAccracy)
                         // 此处设置开发者获取到的方向信息，顺时针0-360
-                        .direction(mCurrentDirection).latitude(firstLatLng.latitude)
-                        .longitude(firstLatLng.longitude).build();
+                        .direction(mCurrentDirection).latitude(mylocation.latitude)
+                        .longitude(mylocation.longitude).build();
                 baiduMap.setMyLocationData(mylocation);
             }
         }
@@ -142,9 +142,9 @@ public class StepService extends Service implements SensorEventListener {
      */
     private OnTrackListener realTimeTraceListener = null;
     //位置采集周期
-    private int gatherInterval = 5;
+    private int gatherInterval = 3;
     //打包周期
-    private int packInterval = 30;
+    private int packInterval = 10;
     // 轨迹服务ID
 //    public static final long serviceId = 213511;
 //杨帅
@@ -102,6 +102,8 @@ public class RunningMapFragment extends QMUIFragment&lt;RunningMapFragmentView, Run
             long endTime = current;
 //            Log.e(TAG, "onViewCreated: " + "hour:" + hour + ",minute" + minute + ",second:" + second);
             getPresenter().queryHistoryTrace(getActivity(), StepService.entityName, startTime, endTime);
+            //查询实时轨迹
+            getPresenter().queryRealTimeTrace(getActivity(),StepService.entityName, startTime);
         }
     }
  
@@ -78,4 +78,136 @@ public class MyMapUtil {
         baiduMap.addOverlay(endOptions);
         return baiduMap.addOverlay(polylineOptions);
     }
+
+
+    public static Overlay drawMapLine(Context context, BaiduMap baiduMap, List<LatLng> points, int lineColor) {
+        OverlayOptions polylineOptions = new PolylineOptions().width(10)
+                .color(context.getResources().getColor(lineColor)).points(points);
+        return baiduMap.addOverlay(polylineOptions);
+    }
+
+    public static double pi = 3.1415926535897932384626;
+    public static double a = 6378245.0;
+    public static double ee = 0.00669342162296594323;
+
+    /**
+     * 将GCJ-02（谷歌地图坐标）转换成BD-09（百度地图坐标）
+     */
+    public static LatLng gcj02_To_Bd09(double gg_lat, double gg_lon) {
+        double x = gg_lon, y = gg_lat;
+        double z = Math.sqrt(x * x + y * y) + 0.00002 * Math.sin(y * pi);
+        double theta = Math.atan2(y, x) + 0.000003 * Math.cos(x * pi);
+        double bd_lon = z * Math.cos(theta) + 0.0065;
+        double bd_lat = z * Math.sin(theta) + 0.006;
+        return new LatLng(bd_lat, bd_lon);
+    }
+
+    public static LatLng wgs84_To_Bd09(double gg_lat, double gg_lon) {
+        LatLng latLng = wgs84togcj02(gg_lat, gg_lon);
+        return gcj02_To_Bd09(latLng.latitude, latLng.longitude);
+    }
+
+    /**
+     * WGS84转GCj02
+     *
+     * @param lng
+     * @param lat
+     * @returns {*[]}
+     */
+    public static LatLng wgs84togcj02(double lat, double lng) {
+        double dlat = transformlat(lng - 105.0, lat - 35.0);
+        double dlng = transformlng(lng - 105.0, lat - 35.0);
+        double radlat = lat / 180.0 * pi;
+        double magic = Math.sin(radlat);
+        magic = 1 - ee * magic * magic;
+        double sqrtmagic = Math.sqrt(magic);
+        dlat = (dlat * 180.0) / ((a * (1 - ee)) / (magic * sqrtmagic) * pi);
+        dlng = (dlng * 180.0) / (a / sqrtmagic * Math.cos(radlat) * pi);
+        double mglat = lat + dlat;
+        double mglng = lng + dlng;
+        return new LatLng(mglat, mglng);
+    }
+
+    private static double transformlat(double lng, double lat) {
+        double ret = -100.0 + 2.0 * lng + 3.0 * lat + 0.2 * lat * lat + 0.1 * lng * lat + 0.2 * Math.sqrt(Math.abs(lng));
+        ret += (20.0 * Math.sin(6.0 * lng * pi) + 20.0 * Math.sin(2.0 * lng * pi)) * 2.0 / 3.0;
+        ret += (20.0 * Math.sin(lat * pi) + 40.0 * Math.sin(lat / 3.0 * pi)) * 2.0 / 3.0;
+        ret += (160.0 * Math.sin(lat / 12.0 * pi) + 320 * Math.sin(lat * pi / 30.0)) * 2.0 / 3.0;
+        return ret;
+    }
+
+    private static double transformlng(double lng, double lat) {
+        double ret = 300.0 + lng + 2.0 * lat + 0.1 * lng * lng + 0.1 * lng * lat + 0.1 * Math.sqrt(Math.abs(lng));
+        ret += (20.0 * Math.sin(6.0 * lng * pi) + 20.0 * Math.sin(2.0 * lng * pi)) * 2.0 / 3.0;
+        ret += (20.0 * Math.sin(lng * pi) + 40.0 * Math.sin(lng / 3.0 * pi)) * 2.0 / 3.0;
+        ret += (150.0 * Math.sin(lng / 12.0 * pi) + 300.0 * Math.sin(lng / 30.0 * pi)) * 2.0 / 3.0;
+        return ret;
+    }
+
+//    /**
+//     * 根据经纬极值计算绽放级别
+//     */
+//    public static float getZoom(List<LatLng> points) {
+//        double maxLng = points.get(points.size() - 1).longitude;
+//        double minLng = points.get(0).longitude;
+//        double maxLat = points.get(points.size() - 1).latitude;
+//        double minLat = points.get(0).latitude;
+//        LatLng tempLatLng;
+//
+//
+//        for (LatLng latLng : points) {
+//            tempLatLng = latLng;
+//            if (tempLatLng.longitude > maxLng) maxLng = tempLatLng.longitude;
+//            if (tempLatLng.longitude < minLng) minLng = tempLatLng.longitude;
+//            if (tempLatLng.latitude > maxLat) maxLat = tempLatLng.latitude;
+//            if (tempLatLng.latitude < minLat) minLat = tempLatLng.latitude;
+//        }
+//
+//        double[] zooms = {50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 25000, 50000, 100000, 200000, 500000, 1000000, 2000000};//级别18到3。
+//        LatLng pointA = new LatLng(maxLat, maxLng);  // 创建点坐标A
+//        LatLng pointB = new LatLng(minLat, minLng);  // 创建点坐标B
+////        double distance = DistanceUtil.getDistance(pointA, pointB);  //获取两点距离,保留小数点后两位
+//        for (int i = 0, zoomLen = zooms.length; i < zoomLen; i++) {
+//            if (zooms[i] - distance > 0) {
+//                return 18 - i + 3;//之所以会多3，是因为地图范围常常是比例尺距离的10倍以上。所以级别会增加3。
+//            }
+//        }
+//        return 18;
+//    }
+
+    /**
+     * 获取经纬度中心点
+     *
+     * @param points
+     * @return
+     */
+    public static LatLng getCenterZoomPosition(List<LatLng> points) {
+        double maxLng = points.get(points.size() - 1).longitude;
+        double minLng = points.get(0).longitude;
+        double maxLat = points.get(points.size() - 1).latitude;
+        double minLat = points.get(0).latitude;
+        double cenLng = (maxLng + minLng) / 2;
+        double cenLat = (maxLat + minLat) / 2;
+        return new LatLng(cenLat, cenLng);
+    }
+
+
+    /**
+     * 经纬度是否为(0,0)点
+     *
+     * @return
+     */
+    public static boolean isZeroPoint(double latitude, double longitude) {
+        return isEqualToZero(latitude) && isEqualToZero(longitude);
+    }
+
+    /**
+     * 校验double数值是否为0
+     *
+     * @param value
+     * @return
+     */
+    public static boolean isEqualToZero(double value) {
+        return Math.abs(value - 0.0) < 0.01 ? true : false;
+    }
 }