Android Studio编写的运动轨迹记录软件

Android 专栏收录该内容
1 篇文章 0 订阅

该软件可实现获取用户位置信息、进行运动轨迹的记录及按日期查询轨迹等功能。在进入软件前需要进行登陆注册,获取用户名作为所记录轨迹的标识。源码链接:https://download.csdn.net/download/weixin_39006917/11255470

对软件的相关内容介绍:

一、开发前的准备

1.在进行开发前需要下载Android Studio软件,并搭建好JDK环境。

2.在百度地图开放平台http://lbsyun.baidu.com/apiconsole/key中创建应用。

应用名称的内容可按个人喜好填写,应用类型选择Android SDK,默认情况下启用服务为全选。关于发布版SHA1和开发版SHA1的获取,笔者主要参考博主朽木不朽提供的方法:https://blog.csdn.net/yuzhiqiang_1993/article/details/79307205。PackageName(包名)是Android Studio中对应项目的包名。如图中包名为package后的内容。

全部填写完成后,生成安全码,即AK。如下图中应用编号为16020055的Android应用的AK为ZKKZn....。

获取AK后在Android Studio中的AndroidManifest.xml文件中进行声明。

 3.在百度鹰眼轨迹中创建服务。http://lbsyun.baidu.com/trace/admin/service。创建完成后获得唯一服务ID。在后续轨迹相关功能开发时会用到服务ID。

二、运动轨迹记录的开发实现

1.初始化轨迹服务

2.采集定位点

3.绘制轨迹

public class DynamicDemo extends Activity implements SensorEventListener {

	// 定位相关
	LocationClient mLocClient;
	public MyLocationListenner myListener = new MyLocationListenner();
	private int mCurrentDirection = 0;
	private double mCurrentLat = 0.0;
	private double mCurrentLon = 0.0;

	MapView mMapView;
	BaiduMap mBaiduMap;

	private TextView info;
	private RelativeLayout progressBarRl;

	private Boolean isRunning = false;

	boolean isFirstLoc = true; // 是否首次定位
	private MyLocationData locData;
	float mCurrentZoom = 18f;//默认地图缩放比例值

	private SensorManager mSensorManager;
	protected OnStartTraceListener  startTraceListener;
	protected OnStopTraceListener stopTraceListener;

	LBSTraceClient client = new LBSTraceClient(DynamicDemo.this);//实例化轨迹服务客户端
	protected static Trace trace = null; // 轨迹服务
	long serviceId  = 213082;//鹰眼服务ID
	private int gatherInterval = 5; // 采集周期(单位 : 秒)
	private int packInterval = 10;//打包周期(单位 : 秒)
	String entityName ;//entity标识
	//轨迹服务类型(0 : 不上传位置数据,也不接收报警信息; 1 : 不上传位置数据,但接收报警信息;2 : 上传位置数据,且接收报警信息)
	int traceType = 2;
	//起点图标
	BitmapDescriptor startBD = BitmapDescriptorFactory.fromResource(R.drawable.ic_me_history_startpoint);
	//终点图标
	BitmapDescriptor finishBD = BitmapDescriptorFactory.fromResource(R.drawable.ic_me_history_finishpoint);

	List<LatLng> points = new ArrayList<LatLng>();//位置点集合
	Polyline mPolyline;//运动轨迹图层
	LatLng last = new LatLng(0, 0);//上一个定位点
	MapStatus.Builder builder;


	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_dyn);
		Bundle bundle = this.getIntent().getExtras();
		String name=bundle.getString("Name2");
		entityName = name;
		initView();
		mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);// 获取传感器管理服务

		// 地图初始化
		mMapView = (MapView) findViewById(R.id.bmapView);
		mBaiduMap = mMapView.getMap();
		// 开启定位图层
		mBaiduMap.setMyLocationEnabled(true);

		mBaiduMap.setMyLocationConfiguration(new MyLocationConfiguration(
				com.baidu.mapapi.map.MyLocationConfiguration.LocationMode.FOLLOWING, true, null));

		/**
		 * 添加地图缩放状态变化监听,当手动放大或缩小地图时,拿到缩放后的比例,然后获取到下次定位,
		 *  给地图重新设置缩放比例,否则地图会重新回到默认的mCurrentZoom缩放比例
		 */
		mBaiduMap.setOnMapStatusChangeListener(new BaiduMap.OnMapStatusChangeListener() {

			@Override
			public void onMapStatusChangeStart(MapStatus arg0) {
				// TODO Auto-generated method stub

			}

			@Override
			public void onMapStatusChangeFinish(MapStatus arg0) {
				mCurrentZoom = arg0.zoom;
			}

			@Override
			public void onMapStatusChange(MapStatus arg0) {
				// TODO Auto-generated method stub

			}
		});

		// 定位初始化
		mLocClient = new LocationClient(this);
		mLocClient.registerLocationListener(myListener);
		LocationClientOption option = new LocationClientOption();
		option.setLocationMode(LocationClientOption.LocationMode.Device_Sensors);//只用gps定位,需要在室外定位。
		option.setOpenGps(true); // 打开gps
		option.setCoorType("bd09ll"); // 设置坐标类型
		option.setScanSpan(1000);
		mLocClient.setLocOption(option);

	}

	private void initView() {

		initTrace();
		Button start = (Button) findViewById(R.id.buttonStart);
		Button finish = (Button) findViewById(R.id.buttonFinish);
		info = (TextView) findViewById(R.id.info);
		progressBarRl = (RelativeLayout) findViewById(R.id.progressBarRl);

		start.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				if (mLocClient != null && !mLocClient.isStarted()) {
					mLocClient.start();
					startService();
					progressBarRl.setVisibility(View.VISIBLE);
					info.setText("GPS信号搜索中,请稍后...");
					mBaiduMap.clear();
				}
			}
		});

		finish.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {

				if (mLocClient != null && mLocClient.isStarted()) {
					mLocClient.stop();
					stopService();
					progressBarRl.setVisibility(View.GONE);

					if (isFirstLoc) {
						points.clear();
						last = new LatLng(0, 0);
						return;
					}

					MarkerOptions oFinish = new MarkerOptions();// 地图标记覆盖物参数配置类
					oFinish.position(points.get(points.size() - 1));
					oFinish.icon(finishBD);// 设置覆盖物图片
					mBaiduMap.addOverlay(oFinish); // 在地图上添加此图层

					//复位
					points.clear();
					last = new LatLng(0, 0);
					isFirstLoc = true;

				}
			}
		});

	}
	private void  initTrace(){
		trace = new Trace(getApplicationContext(), serviceId, entityName,traceType);
		initStartListener();
		initStopListener();
		// 设置采集周期
		client.setInterval(gatherInterval, packInterval);

	}
	private void initStartListener() {
		//实例化开启轨迹服务回调接口
		startTraceListener = new OnStartTraceListener() {
			//开启轨迹服务回调接口(arg0 : 消息编码,arg1 : 消息内容,详情查看类参考)
			@Override
			public void onTraceCallback(int arg0, String arg1) {
				Log.i(TAG,"onTraceCallback开启轨迹服务回调" + arg0 + ",消息内容 : " + arg1 + "]");
				//showMessage("开启轨迹服务");///添加toast
				if (0 == arg0 || 10006 == arg0 || 10008 == arg0) {
					isRunning = true;
			//		startRefreshThread(true);
				}
			}
			//轨迹服务推送接口(用于接收服务端推送消息,arg0 : 消息类型,arg1 : 消息内容,详情查看类参考)
			@Override
			public void onTracePushCallback(byte arg0, String arg1) {
				Log.i(TAG,"轨迹服务推送接口消息 [消息类型 : " + arg0 + ",消息内容 : " + arg1 + "]");
			}
		};
	}
	private void initStopListener() {
		stopTraceListener = new OnStopTraceListener() {
			public void onStopTraceSuccess() {// 轨迹服务停止成功
				Log.i(TAG,"onStopTraceSuccess关闭轨迹服务");
		//		showMessage("停止轨迹服务成功");
		//		locHander.sendEmptyMessage(RUN_STOP);
				isRunning = false;
		//		startRefreshThread(false);
			}
			// 轨迹服务停止失败(arg0 : 错误编码,arg1 : 消息内容,详情查看类参考)
			public void onStopTraceFailed(int arg0, String arg1) {
			}
		};
	}
	private void startService() {
		if (! isRunning) {
			Log.i(TAG, "Start StepService");
			isRunning = true;
			client.startTrace(trace, startTraceListener);//开启轨迹服务
		}
	}
	private void stopService() {
		Log.i(TAG, "stopService");
		client.stopTrace(trace, stopTraceListener);
	}

	double lastX;
	@Override
	public void onSensorChanged(SensorEvent sensorEvent) {
		double x = sensorEvent.values[SensorManager.DATA_X];

		if (Math.abs(x - lastX) > 1.0) {
			mCurrentDirection = (int) x;

			if (isFirstLoc) {
				lastX = x;
				return;
			}

			locData = new MyLocationData.Builder().accuracy(0)
					// 此处设置开发者获取到的方向信息,顺时针0-360
					.direction(mCurrentDirection).latitude(mCurrentLat).longitude(mCurrentLon).build();
			mBaiduMap.setMyLocationData(locData);
		}
		lastX = x;

	}

	@Override
	public void onAccuracyChanged(Sensor sensor, int i) {

	}

	/**
	 * 定位SDK监听函数
	 */
	public class MyLocationListenner implements BDLocationListener {

		@Override
		public void onReceiveLocation(final BDLocation location) {

			if (location == null || mMapView == null) {
				return;
			}

			//注意这里只接受gps点,需要在室外定位。
			if (location.getLocType() == BDLocation.TypeGpsLocation) {

				info.setText("GPS信号弱,请稍后...");

				if (isFirstLoc) {//首次定位
					//第一个点很重要,决定了轨迹的效果,gps刚开始返回的一些点精度不高,尽量选一个精度相对较高的起始点
					LatLng ll = null;

					ll = getMostAccuracyLocation(location);
					if(ll == null){
						return;
					}
					isFirstLoc = false;
					points.add(ll);//加入集合
					last = ll;

					//显示当前定位点,缩放地图
					locateAndZoom(location, ll);

					//标记起点图层位置
					MarkerOptions oStart = new MarkerOptions();// 地图标记覆盖物参数配置类
					oStart.position(points.get(0));// 覆盖物位置点,第一个点为起点
					oStart.icon(startBD);// 设置覆盖物图片
					mBaiduMap.addOverlay(oStart); // 在地图上添加此图层

					progressBarRl.setVisibility(View.GONE);

					return;//画轨迹最少得2个点,首地定位到这里就可以返回了
				}

				//从第二个点开始
				LatLng ll = new LatLng(location.getLatitude(), location.getLongitude());
				//sdk回调gps位置的频率是1秒1个,位置点太近动态画在图上不是很明显,可以设置点之间距离大于为5米才添加到集合中
				if (DistanceUtil.getDistance(last, ll) < 5) {
					return;
				}

				points.add(ll);//如果要运动完成后画整个轨迹,位置点都在这个集合中

				last = ll;

				//显示当前定位点,缩放地图
				locateAndZoom(location, ll);

				//清除上一次轨迹,避免重叠绘画
				mMapView.getMap().clear();

				//起始点图层也会被清除,重新绘画
				MarkerOptions oStart = new MarkerOptions();
				oStart.position(points.get(0));
				oStart.icon(startBD);
				mBaiduMap.addOverlay(oStart);

				//将points集合中的点绘制轨迹线条图层,显示在地图上
				OverlayOptions ooPolyline = new PolylineOptions().width(13).color(0xAAFF0000).points(points);
				mPolyline = (Polyline) mBaiduMap.addOverlay(ooPolyline);
			}
		}

	}

	private void locateAndZoom(final BDLocation location, LatLng ll) {
		mCurrentLat = location.getLatitude();
		mCurrentLon = location.getLongitude();
		locData = new MyLocationData.Builder().accuracy(0)
				// 此处设置开发者获取到的方向信息,顺时针0-360
				.direction(mCurrentDirection).latitude(location.getLatitude())
				.longitude(location.getLongitude()).build();
		mBaiduMap.setMyLocationData(locData);

		builder = new MapStatus.Builder();
		builder.target(ll).zoom(mCurrentZoom);
		mBaiduMap.animateMapStatus(MapStatusUpdateFactory.newMapStatus(builder.build()));
	}

	/**
	 * 首次定位很重要,选一个精度相对较高的起始点
	 * 注意:如果一直显示gps信号弱,说明过滤的标准过高了,
	 你可以将location.getRadius()>25中的过滤半径调大,比如>40,
	 并且将连续5个点之间的距离DistanceUtil.getDistance(last, ll ) > 5也调大一点,比如>10,
	 这里不是固定死的,你可以根据你的需求调整,如果你的轨迹刚开始效果不是很好,你可以将半径调小,两点之间距离也调小,
	 gps的精度半径一般是10-50米
	 */
	private LatLng getMostAccuracyLocation(BDLocation location){

		if (location.getRadius()>40) {//gps位置精度大于40米的点直接弃用
			return null;
		}

		LatLng ll = new LatLng(location.getLatitude(), location.getLongitude());

		if (DistanceUtil.getDistance(last, ll ) > 10) {
			last = ll;
			points.clear();//有任意连续两点位置大于10,重新取点
			return null;
		}
		points.add(ll);
		last = ll;
		//有5个连续的点之间的距离小于10,认为gps已稳定,以最新的点为起始点
		if(points.size() >= 5){
			points.clear();
			return ll;
		}
		return null;
	}

	@Override
	protected void onPause() {
		mMapView.onPause();
		super.onPause();
	}

	@Override
	protected void onResume() {
		mMapView.onResume();
		super.onResume();
		// 为系统的方向传感器注册监听器
		mSensorManager.registerListener(this, mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION),
				SensorManager.SENSOR_DELAY_UI);
	}

	@Override
	protected void onStop() {
		// 取消注册传感器监听
		mSensorManager.unregisterListener(this);
		super.onStop();
	}

	@Override
	protected void onDestroy() {
		// 退出时销毁定位
		mLocClient.unRegisterLocationListener(myListener);
		if (mLocClient != null && mLocClient.isStarted()) {
			mLocClient.stop();
		}
		// 关闭定位图层
		mBaiduMap.setMyLocationEnabled(false);
		mMapView.getMap().clear();
		mMapView.onDestroy();
		mMapView = null;
		startBD.recycle();
		finishBD.recycle();
		super.onDestroy();
	}

}

三、历史轨迹查询

public class RecordActivity extends Activity {


    private String TAG = "RecordActivity1";
    private Button btn_record;
    private MapView mapView;
    private static BaiduMap mBaiduMap;
    private static PolylineOptions polyline = null;// 路线覆盖物
    Marker startMarker = null;// 起点图标覆盖物
    Marker endMarker = null;// 终点图标覆盖物
    OverlayOptions option1 = null;
    OverlayOptions option2 = null;
    protected static OverlayOptions overlay;// 覆盖物
    private static BitmapDescriptor bmStart;// 起点图标
    private static BitmapDescriptor bmEnd;// 终点图标
    protected static MapStatusUpdate msUpdate = null;
    LBSTraceClient client = new LBSTraceClient(RecordActivity.this);//实例化轨迹服务客户端
    protected static Trace trace = null;// 轨迹服务
    long serviceId = 213082;//鹰眼服务ID
    String entityName  ;//entity标识
    int traceType = 2;//轨迹服务类型(0 : 不上传位置数据,也不接收报警信息; 1 : 不上传位置数据,但接收报警信息;2 : 上传位置数据,且接收报警信息)
    protected static OnTrackListener trackListener = null;//Track监听器
    private int startTime = 0;
    private int endTime = 0;
    private int year = 0;//查询日期的年月日
    private int month = 0;
    private int day = 0;
    String record_date;
    private static int isProcessed = 0;
    boolean isfirst = true;
    LatLng pouse,restart;


    private Handler mHandler = new Handler() {
        public void handleMessage(android.os.Message msg) {
            switch (msg.what) {
                case MsgConfig.SHOW_INFO:
                    String text = (String) msg.getData().get("content");
                    btn_record.setText("选择日期");
                    Toast.makeText(RecordActivity.this, text, Toast.LENGTH_LONG).show();
                    break;
                case MsgConfig.SHOW_HISTORY:
                    btn_record.setText("查询完毕");
                    break;
            }
        }

        ;
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.i(TAG, "onCreate");
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        setContentView(R.layout.activity_record);
       Bundle bundle = this.getIntent().getExtras();
        String name=bundle.getString("Name1");
       entityName = name;
        initView();
        initTrace();
    }

    private void initTrace() {
        trace = new Trace(RecordActivity.this, serviceId, entityName, traceType);
        initOnTrackListener();
        client.setOnTrackListener(trackListener);
        mapView = (MapView) findViewById(R.id.record_bmapView);
        mBaiduMap = mapView.getMap();
        mapView.showZoomControls(false);
    }

    /**
     * 初始化OnTrackListener
     */
    private void initOnTrackListener() {
        trackListener = new OnTrackListener() {
            @Override
            public void onRequestFailedCallback(String arg0) { // 请求失败回调接口
                Looper.prepare();
                Looper.loop();
            }

            @Override
            public void onQueryHistoryTrackCallback(String arg0) {// 查询历史轨迹回调接口
                Log.i(TAG, "track请求成功回调接口消息 : " + arg0);
                showHistoryTrack(arg0);
                Message msg = new Message();
                msg.what = MsgConfig.SHOW_HISTORY;
                mHandler.sendMessage(msg);
                super.onQueryHistoryTrackCallback(arg0);
            }
        };
    }

    //用来展示历史轨迹
    private void showHistoryTrack(String arg0) {
        Log.i(TAG, "查询回调展示,拿到回调的数据1");
        Log.i(TAG, "查询回调展示,拿到回调的数据2");
        HistoryTrackData historyTrackData = GsonService.parseJson(arg0,
                HistoryTrackData.class);
        List<LatLng> latLngList = new ArrayList<LatLng>();
        if (historyTrackData != null && historyTrackData.getStatus() == 0) {
            Log.i(TAG, "查询回调展示,拿到回调的数据,数据不为空且数据status为0");
            if (historyTrackData.getListPoints() != null) {
                latLngList.addAll(historyTrackData.getListPoints());
            }
            drawHistoryTrack(latLngList, historyTrackData.distance);// 绘制历史轨迹
        } else {
            Log.i(TAG, "查询回调展示,拿到回调的数据,数据为空或数据status为0");
            Message msg = new Message();
            Bundle data = new Bundle();
            data.putString("content", "当天没有进行走动");
            msg.setData(data);
            msg.what = MsgConfig.SHOW_INFO;
            mHandler.sendMessage(msg);
            Log.i(TAG, "查询回调展示,拿到回调的数据,数据为空或数据status为0,在toast后面");
        }
    }

    /**
     * 绘制历史轨迹
     */
    private void drawHistoryTrack(final List<LatLng> points, final double distance) {
        Log.i(TAG, "查询回调展示,拿到回调的数据,画出轨迹");
        mBaiduMap.clear();// 绘制新覆盖物前,清空之前的覆盖物
        if (points == null || points.size() == 0) {
            Looper.prepare();
            Message msg = new Message();
            Bundle data = new Bundle();
            data.putString("content", "当天没有进行走动");
            msg.setData(data);
            msg.what = MsgConfig.SHOW_INFO;
            mHandler.sendMessage(msg);
            Looper.loop();
            resetMarker();
        } else if (points.size() > 1) {
            for(int i=0;i<3;i++)
            {
                points.remove(points.size() - 1);
            }
            pouse = points.get(0);
            restart = points.get(points.size() - 1);
            LatLng llC = points.get(0);
            LatLng llD = points.get(points.size() - 1);
            LatLngBounds bounds = new LatLngBounds.Builder()
                    .include(llC).include(llD).build();
            msUpdate = MapStatusUpdateFactory.newLatLngBounds(bounds);
            bmStart = BitmapDescriptorFactory.fromResource(R.drawable.ic_me_history_startpoint);
            bmEnd = BitmapDescriptorFactory.fromResource(R.drawable.ic_me_history_finishpoint);
            // 添加终点图标
            option2 = new MarkerOptions()
                    .position(restart).icon(bmStart)
                    .zIndex(9).draggable(true);
            option1 = new MarkerOptions().position(pouse)
                    .icon(bmEnd).zIndex(9).draggable(true);
            startMarker = (Marker) mBaiduMap.addOverlay(option2);
            // 添加起点图标
            endMarker = (Marker) mBaiduMap.addOverlay(option1);
            // 添加路线(轨迹)
            polyline = new PolylineOptions().width(10)
                    .color(Color.RED).points(points);
            addMarker();
            Message msg = new Message();
            msg.what = MsgConfig.SHOW_HISTORY;
            mHandler.sendMessage(msg);
            Looper.prepare();
            Looper.loop();
            isfirst = false;
            pouse=points.get(0);
        } else {
            Message msg = new Message();
            Bundle data = new Bundle();
            data.putString("content", "当天的走动量太少,被系统忽略");
            msg.setData(data);
            msg.what = MsgConfig.SHOW_INFO;
            mHandler.sendMessage(msg);
        }
    }

    /**
     * 重置覆盖物
     */
    private void resetMarker() {
        startMarker = null;
        endMarker = null;
        polyline = null;
    }

    /**
     * 添加地图覆盖物
     */
    protected static void addMarker() {
        if (null != msUpdate) {
            mBaiduMap.setMapStatus(msUpdate);
        }
        // 路线覆盖物
        if (null != polyline) {
            mBaiduMap.addOverlay(polyline);
        }
        // 实时点覆盖物
        if (null != overlay) {
            mBaiduMap.addOverlay(overlay);
        }
    }

    private void initView() {
        btn_record = (Button) findViewById(R.id.record_date);
        btn_record.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                btn_record.setText("正在查询历史轨迹,请稍候");
                queryTrack();
            }
        });
    }

    /**
     * 轨迹查询(先选择日期,再根据是否纠偏,发送请求)
     */
    private void queryTrack() {
        Log.i(TAG, "开始查询轨迹,选择日期");
        // 选择日期
        int[] date = null;
        DisplayMetrics dm = new DisplayMetrics();
        this.getWindowManager().getDefaultDisplay().getMetrics(dm);
        int width = dm.widthPixels;
        int height = dm.heightPixels;
        if (year == 0 && month == 0 && day == 0) {
            String curDate = DateUtils.getCurrentDate();
            date = DateUtils.getYMDArray(curDate, "-");
        }
        if (date != null) {
            year = date[0];
            month = date[1];
            day = date[2];
        }
        DateDialog dateDiolog = new DateDialog(RecordActivity.this, new PriorityListener() {
            public void refreshPriorityUI(String sltYear, String sltMonth,
                                          String sltDay, CallBack back) {
                Log.i(TAG, sltYear + sltMonth + sltDay);
                year = Integer.parseInt(sltYear);
                month = Integer.parseInt(sltMonth);
                day = Integer.parseInt(sltDay);
                if (month > 9) {
                    if (day > 9) {
                        record_date = year + "-" + month + "-" + day;
                    } else {
                        record_date = year + "-" + month + "-" + "0" + day;
                    }
                } else {
                    if (day > 9) {
                        record_date = year + "-" + "0" + month + "-" + day;
                    } else {
                        record_date = year + "-" + "0" + month + "-" + "0" + day;
                    }
                }
                String st = year + "年" + month + "月" + day + "日0时0分0秒";
                String et = year + "年" + month + "月" + day + "日23时59分59秒";
                startTime = Integer.parseInt(DateUtils.getTimeToStamp(st));
                endTime = Integer.parseInt(DateUtils.getTimeToStamp(et));
                back.execute();
            }
        }, new CallBack() {
            public void execute() {
                Log.i(TAG, "执行查询轨迹");
                queryHistoryTrack();
            }
        }, year, month, day, width, height, "选择日期", 1);
        Window window = dateDiolog.getWindow();
        window.setGravity(Gravity.CENTER); // 此处可以设置dialog显示的位置
        dateDiolog.setCancelable(true);
        dateDiolog.show();
    }

    /**
     * 查询历史轨迹
     */
    private void queryHistoryTrack() {
        int simpleReturn = 0;// 是否返回精简的结果(0 : 否,1 : 是)
        // 开始时间
        if (startTime == 0) {
            startTime = (int) (System.currentTimeMillis() / 1000 - 12 * 60 * 60);
        }
        if (endTime == 0) {
            endTime = (int) (System.currentTimeMillis() / 1000);
        }
        int pageSize = 1000;// 分页大小
        int pageIndex = 1; // 分页索引
        client.queryHistoryTrack(serviceId, entityName, simpleReturn, startTime, endTime,
                pageSize, pageIndex, trackListener);
        Log.i(TAG, "调用client开始查询");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        client.onDestroy();
        mapView.onDestroy();
    }
}

第二部分的轨迹记录过程将采集的定位点集合上传至百度服务器,历史轨迹查询部分再回调记录的定位点,绘制出轨迹。在百度的Web轨迹管理台中进入对应的已创建服务,可实现轨迹的管理和终端用户的管理。

  • 1
    点赞
  • 2
    评论
  • 63
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 像素格子 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值