百度鷹眼軌跡查詢歷史軌跡並顯示在地圖上

import android.graphics.Color;
import android.os.Bundle;
import android.widget.RelativeLayout;

import com.baidu.mapapi.map.BaiduMap;
import com.baidu.mapapi.map.BitmapDescriptor;
import com.baidu.mapapi.map.BitmapDescriptorFactory;
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.trace.LBSTraceClient;
import com.baidu.trace.api.track.HistoryTrackRequest;
import com.baidu.trace.api.track.HistoryTrackResponse;
import com.baidu.trace.api.track.OnTrackListener;
import com.baidu.trace.api.track.SortType;
import com.baidu.trace.api.track.TrackPoint;
import com.baidu.trace.model.StatusCodes;
import com.zxrf.android.R;
import com.zxrf.android.common.activity.CommonActivity;
import com.zxrf.android.common.base.SupportDisplay;
import com.zxrf.android.common.util.ToastUtil;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class TrackqueryActivity extends CommonActivity {
    // 軌跡服務ID
    private long serviceId = user_serviceId;
    // 設備標識
    private String entityName = getIMEI();
    private  HistoryTrackRequest historyTrackRequest;
    private BaiduMap Map;
    private MapView map_view;
    private LBSTraceClient mTraceClient;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_trackquery);
        map_view = (MapView) findViewById(R.id.map_view);
        Map = map_view.getMap();
        mTraceClient = new LBSTraceClient(getApplicationContext());
        historyTrackRequest = new HistoryTrackRequest(mSequenceGenerator.incrementAndGet(), serviceId, entityName);
        Init();
    }

    private AtomicInteger mSequenceGenerator = new AtomicInteger();

    private void Init(){

//設置軌跡查詢起止時間
// 開始時間(單位：秒)
        long startTime = System.currentTimeMillis() / 1000 - 12 * 60 * 60;
// 結束時間(單位：秒)
        long endTime = System.currentTimeMillis() / 1000;
// 設置開始時間
        historyTrackRequest.setStartTime(startTime);
// 設置結束時間
        historyTrackRequest.setEndTime(endTime);
        // 查詢歷史軌跡
        historyTrackRequest.setPageIndex(pageIndex);
        historyTrackRequest.setPageSize(PAGE_SIZE);
        mTraceClient.queryHistoryTrack(historyTrackRequest, mTrackListener);
    }

    /**
     * 軌跡點集合
     */
    private List<LatLng> trackPoints = new ArrayList<>();
    public static final int PAGE_SIZE = 5000;
    /**
     * 軌跡排序規則
     */
    private SortType sortType = SortType.asc;

    private int pageIndex = 1;
    // 初始化軌跡監聽器
    OnTrackListener mTrackListener = new OnTrackListener() {
        // 歷史軌跡回調
        @Override
        public void onHistoryTrackCallback(HistoryTrackResponse response) {
            int toal = response.getTotal();
            if (StatusCodes.SUCCESS != response.getStatus()) {
                ToastUtil.show(response.getMessage());
            }else if (0 == toal){
                ToastUtil.show("未查詢到軌跡");
            }else {
                List<TrackPoint> points = response.getTrackPoints();
                if (null != points) {
                    for (TrackPoint trackPoint : points) {
                        if (!MapUtils.isZeroPoint(trackPoint.getLocation().getLatitude(),
                                trackPoint.getLocation().getLongitude())) {
                            trackPoints.add(new LatLng(trackPoint.getLocation().latitude, trackPoint.getLocation().longitude));
                        }
                    }
                }
            }
            if (toal > PAGE_SIZE*pageIndex){
                historyTrackRequest.setPageIndex(++pageIndex);
                Init();
            }
            else {
                drawHistoryTrack(trackPoints, sortType);
            }


        }
    };
    @Override
    protected void resetLayout() {
        RelativeLayout layout = (RelativeLayout) findViewById(R.id.rl_activity_track_query_viewgroup);
        SupportDisplay.resetAllChildViewParam(layout);
    }

    public  BitmapDescriptor bmStart = null;
    public  BitmapDescriptor bmEnd = null;
    public  BitmapDescriptor bmArrowPoint = null;
    /**
     * 路線覆蓋物
     */
    public Overlay polylineOverlay = null;
    private Marker mMoveMarker = null;
    private MapStatus mapStatus = null;
    /**
     * 繪製歷史軌跡
     */
    public void drawHistoryTrack( final List<LatLng> points, SortType sortType) {
        // 繪製新覆蓋物前，清空以前的覆蓋物
        Map.clear();
        if (null != mMoveMarker) {
            mMoveMarker.remove();
            mMoveMarker = null;
        }
        if (points == null || points.size() == 0) {
            if (null != polylineOverlay) {
                polylineOverlay.remove();
                polylineOverlay = null;
            }
            return;
        }
//資源文件
        bmStart = BitmapDescriptorFactory.fromResource(R.mipmap.icon_start);
        bmEnd = BitmapDescriptorFactory.fromResource(R.mipmap.icon_end);
        bmArrowPoint = BitmapDescriptorFactory.fromResource(R.mipmap.icon_point);
        if (points.size() == 1) {
            OverlayOptions startOptions = new MarkerOptions().position(points.get(0)).icon(bmStart)
                    .zIndex(9).draggable(true);
            Map.addOverlay(startOptions);
            animateMapStatus(points.get(0), 18.0f);
            return;
        }

        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);
        }

        // 添加起點圖標
        OverlayOptions startOptions = new MarkerOptions()
                .position(startPoint).icon(bmStart)
                .zIndex(9).draggable(true);
        // 添加終點圖標
        OverlayOptions endOptions = new MarkerOptions().position(endPoint)
                .icon(bmEnd).zIndex(9).draggable(true);

        // 添加路線（軌跡）
        OverlayOptions polylineOptions = new PolylineOptions().width(10)
                .color(Color.BLUE).points(points);

        Map.addOverlay(startOptions);
        Map.addOverlay(endOptions);
        polylineOverlay = Map.addOverlay(polylineOptions);

        OverlayOptions markerOptions =
                new MarkerOptions().flat(true).anchor(0.5f, 0.5f).icon(bmArrowPoint)
                        .position(points.get(points.size() - 1))
                        .rotate((float) MapUtils.getAngle(points.get(0), points.get(1)));
        mMoveMarker = (Marker) Map.addOverlay(markerOptions);
        animateMapStatus(points);

    }
    public void animateMapStatus(LatLng point, float zoom) {
        MapStatus.Builder builder = new MapStatus.Builder();
        mapStatus = builder.target(point).zoom(zoom).build();
        Map.animateMapStatus(MapStatusUpdateFactory.newMapStatus(mapStatus));
    }

    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());
        Map.animateMapStatus(msUpdate);
    }
}

 

MapUtils類

 

import com.baidu.mapapi.model.LatLng;

/**
 * Created by Timor on 2017/6/30.
 */

public class MapUtils {


    /**
     * 經緯度是否爲(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;
    }

    /**
     * 根據兩點算取圖標轉的角度
     */
    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 double getSlope(LatLng fromPoint, LatLng toPoint) {
        if (toPoint.longitude == fromPoint.longitude) {
            return Double.MAX_VALUE;
        }
        return (toPoint.latitude - fromPoint.latitude) / (toPoint.longitude - fromPoint.longitude);
    }
}