开发Android高德地图

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u014736095/article/details/71629697

Android高德地图记录运动轨迹，并自动定位视图到2点之间且自动缩放

废话不错说，这次我们来实现一个记录运动路径的功能，当然需要有高德地图sdk的帮助，感谢高德地图。如下：

首先把高德地图的sdk集成进项目，这个高德地图的开放平台网站已经说的很清楚了，我就不在这里多废话了。

http://lbs.amap.com/api/android-sdk/summary/

等到可以显示一个以北京为中心的地图，并且log日志没有错误的信息的时候就代表你已经成功了。可以

开始踏上开发运动轨迹之路了

2个代码如下:

扫描二维码关注公众号，回复： 6237886 查看本文章

StepAndGaoDeMapActivity.java(记录运动轨迹)

example.kuby.myapplication;

import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;

import com.amap.api.location.AMapLocation;
import com.amap.api.location.AMapLocationClient;
import com.amap.api.location.AMapLocationClientOption;
import com.amap.api.location.AMapLocationListener;
import com.amap.api.maps2d.AMap;
import com.amap.api.maps2d.AMapUtils;
import com.amap.api.maps2d.CameraUpdateFactory;
import com.amap.api.maps2d.LocationSource;
import com.amap.api.maps2d.MapView;
import com.amap.api.maps2d.model.BitmapDescriptor;
import com.amap.api.maps2d.model.BitmapDescriptorFactory;
import com.amap.api.maps2d.model.Circle;
import com.amap.api.maps2d.model.CircleOptions;
import com.amap.api.maps2d.model.LatLng;
import com.amap.api.maps2d.model.Marker;
import com.amap.api.maps2d.model.MarkerOptions;
import com.amap.api.maps2d.model.MyLocationStyle;
import com.amap.api.maps2d.model.PolylineOptions;
import com.example.kuby.myapplication.map.LuJingActivity;
import com.example.kuby.myapplication.map.SensorEventHelper;
import com.example.kuby.myapplication.utils.LogUtils;
import com.example.kuby.myapplication.utils.MathUtils;

import java.util.ArrayList;
import java.util.List;

import butterknife.BindView;
import butterknife.ButterKnife;
import butterknife.OnClick;

public class StepAndGaoDeMapActivity extends AppCompatActivity {

    public static final String POSITION_LIST = "position_list";
    @BindView(R.id.btn_showexample)
    Button btnShowexample;
    private CountDownTimer countDownTimer = new CountDownTimer(24 * 60 * 60 * 1000, 1000) {
        @Override
        public void onTick(long millisUntilFinished) {
            totalTime += 1;
            LogUtils.i("totaltime---> " + totalTime);
            String s = formatLongToTimeStr(totalTime);
            tvYongshi.setText(s);
            tvUseTime.setText(s);
        }

        @Override
        public void onFinish() {

        }
    };

    @BindView(R.id.tv_gongli)
    TextView tvGongli;
    @BindView(R.id.tv_shudu)
    TextView tvShudu;
    @BindView(R.id.tv_yongshi)
    TextView tvYongshi;
    @BindView(R.id.tv_qianka)
    TextView tvQianka;
    @BindView(R.id.btn_showmap)
    Button btnShowmap;
    @BindView(R.id.btn_start)
    Button btnStart;
    @BindView(R.id.linear_control)
    LinearLayout linearControl;
    @BindView(R.id.map)
    MapView map;
    @BindView(R.id.tv_map_distance)
    TextView tvDistance;
    @BindView(R.id.tv_map_use_time)
    TextView tvUseTime;
    @BindView(R.id.linear_bottom)
    LinearLayout linearBottom;
    @BindView(R.id.iv_close_mapview)
    ImageView ivCloseMapview;
    @BindView(R.id.relative_map)
    RelativeLayout relativeMap;

    /**
     * 总时间,单位s
     */
    private int totalTime;


    private MapView mMapView;
    private AMap aMap;
    private LocationSource.OnLocationChangedListener mListener;
    private AMapLocationClient mlocationClient;
    private AMapLocationClientOption mLocationOption;


    private boolean mFirstFix;
    private static final int STROKE_COLOR = Color.argb(180, 3, 145, 255);
    private static final int FILL_COLOR = Color.argb(10, 0, 0, 180);
    private Circle mCircle;
    private Marker mLocMarker;
    public static final String LOCATION_MARKER_FLAG = "mylocation";
    private SensorEventHelper mSensorHelper;

    //记录轨迹
    private ArrayList<LatLng> latLngs = new ArrayList();


    /**
     * 新旧轨迹
     */
    private LatLng oldLatLng, newLatLng;
    /**
     * 是否为首次记录路径
     */
    private boolean isFirstRecord = true;
    /**
     * 是否开始记录轨迹
     */
    private boolean isStartRecord;
    /**
     * 单位s
     */
    private int totalDistance;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_step_and_gao_de_map);
        ButterKnife.bind(this);

        //获取地图控件引用
        mMapView = (MapView) findViewById(R.id.map);
        //在activity执行onCreate时执行mMapView.onCreate(savedInstanceState)，创建地图
        mMapView.onCreate(savedInstanceState);

        //初始化地图控制器对象
        init();
    }

    private void init() {
        if (aMap == null) {
            aMap = mMapView.getMap();
            setUpMap();
        }
        mSensorHelper = new SensorEventHelper(this);
        if (mSensorHelper != null) {
            mSensorHelper.registerSensorListener();
        }

    }

    public String formatLongToTimeStr(int l) {
        int hour = 0;
        int minute = 0;
        int second = l;
        if (second > 60) {
            minute = second / 60;         //取整
            second = second % 60;         //取余
        }

        if (minute > 60) {
            hour = minute / 60;
            minute = minute % 60;
        }
        String strtime = String.format("%02d", hour) + "：" + String.format("%02d", minute) + "：" + String.format("%02d", second);
        return strtime;

    }

    @OnClick({R.id.btn_showmap, R.id.btn_start, R.id.iv_close_mapview,R.id.btn_showexample})
    public void onViewClicked(View view) {
        switch (view.getId()) {
            case R.id.btn_showmap:
                linearControl.setVisibility(View.GONE);
                relativeMap.setVisibility(View.VISIBLE);
                break;
            case R.id.btn_start:
                if (btnStart.getTag() == null) {
                    //点击go
                    btnStart.setTag(0);
                    btnStart.setText("cancel");
                    isStartRecord = true;
                    countDownTimer.start();
                } else {
                    //点击cancel
                    btnStart.setTag(null);
                    btnStart.setText("Go");
                    isStartRecord = false;
                    countDownTimer.cancel();
                }
                break;
            case R.id.iv_close_mapview:
                linearControl.setVisibility(View.VISIBLE);
                relativeMap.setVisibility(View.GONE);
                break;
            case R.id.btn_showexample:
                Intent intent = new Intent(this, LuJingActivity.class);

                latLngs.clear();
                latLngs.add(new LatLng(22.549417000, 113.943233000));
                latLngs.add(new LatLng(22.5496300000, 113.9451270000));
                latLngs.add(new LatLng(22.5484310000, 113.9451640000));
                latLngs.add(new LatLng(22.5468610000, 113.9452770000));
                latLngs.add(new LatLng(22.5431350000, 113.9453630000));
                intent.putParcelableArrayListExtra(POSITION_LIST, latLngs);
                startActivity(intent);
                break;
        }
    }

    /**
     * 设置一些amap的属性
     */
    private void setUpMap() {
        // 自定义系统定位小蓝点
        MyLocationStyle myLocationStyle = new MyLocationStyle();
        myLocationStyle.myLocationIcon(BitmapDescriptorFactory
                .fromResource(R.mipmap.location_marker));// 设置小蓝点的图标
        myLocationStyle.strokeColor(Color.BLACK);// 设置圆形的边框颜色
        myLocationStyle.radiusFillColor(Color.argb(100, 0, 0, 180));// 设置圆形的填充颜色
        // myLocationStyle.anchor(int,int)//设置小蓝点的锚点
        myLocationStyle.strokeWidth(1.0f);// 设置圆形的边框粗细

        aMap.setMyLocationStyle(myLocationStyle);
        aMap.setLocationSource(new LocationSource() {
            @Override
            public void activate(OnLocationChangedListener listener) {
                mListener = listener;
                if (mlocationClient == null) {
                    mlocationClient = new AMapLocationClient(StepAndGaoDeMapActivity.this);
                    mLocationOption = new AMapLocationClientOption();
                    //设置定位监听
                    mlocationClient.setLocationListener(new AMapLocationListener() {
                        @Override
                        public void onLocationChanged(AMapLocation amapLocation) {
                            /*if (mListener != null && amapLocation != null) {
                                if (amapLocation != null
                                        && amapLocation.getErrorCode() == 0) {
                                    mListener.onLocationChanged(amapLocation);// 显示系统小蓝点
                                } else {
                                    String errText = "定位失败," + amapLocation.getErrorCode()+ ": " + amapLocation.getErrorInfo();
                                    Log.e("AmapErr", errText);
                                }
                            }*/

                            int gpsStrength = amapLocation.getGpsAccuracyStatus();
                            switch (gpsStrength) {
                                case AMapLocation.GPS_ACCURACY_GOOD://卫星信号强
                                    LogUtils.i("卫星信号强");
                                    break;
                                case AMapLocation.GPS_ACCURACY_BAD://卫星信号弱
                                    LogUtils.i("卫星信号弱");
                                    break;
                                case AMapLocation.GPS_ACCURACY_UNKNOWN://卫星状态未知
                                    LogUtils.i("卫星状态未知");
                                    break;
                            }

                            if (mListener != null && amapLocation != null) {
                                if (amapLocation != null
                                        && amapLocation.getErrorCode() == 0) {

                                    //mLocationErrText.setVisibility(View.GONE);
                                    LatLng location = new LatLng(amapLocation.getLatitude(), amapLocation.getLongitude());

                                    if (!mFirstFix) {//是否绘制过一次了
                                        mFirstFix = true;
                                        addCircle(location, amapLocation.getAccuracy());//添加定位精度圆
                                        addMarker(location);//添加定位图标
                                        mSensorHelper.setCurrentMarker(mLocMarker);//定位图标旋转
                                        LogUtils.i("-----------------第一次定位-------------------------");
                                    } else {
                                        LogUtils.i("经纬度:[" + amapLocation.getLatitude() + "," + amapLocation.getLongitude() + "]");
                                        mCircle.setCenter(location);
                                        mCircle.setRadius(amapLocation.getAccuracy());
                                        mLocMarker.setPosition(location);
                                    }
                                    aMap.moveCamera(CameraUpdateFactory.newLatLngZoom(location, 18));

                                    if (isStartRecord) {
                                        //记录轨迹:叠加绘制
                                        newLatLng = location;
                                        if (isFirstRecord) {
                                            //记录轨迹:记录第一次的定位信息
                                            oldLatLng = newLatLng;
                                            isFirstRecord = false;
                                            latLngs.add(newLatLng);
                                        } else if (isDifferent(oldLatLng, newLatLng)) {
                                            addLinePointAndDraw(aMap, oldLatLng, newLatLng);
                                            oldLatLng = newLatLng;
                                        }
                                        LogUtils.i("newposition经纬度:[" + newLatLng.latitude + "," + newLatLng.longitude + "]");
                                        LogUtils.i("oldposition经纬度:[" + oldLatLng.latitude + "," + oldLatLng.longitude + "]");
                                    }

                                } else {
                                    String errText = "定位失败," + amapLocation.getErrorCode() + ": " + amapLocation.getErrorInfo();
                                    Log.e("AmapErr", errText);
                                    //mLocationErrText.setVisibility(View.VISIBLE);
                                    //mLocationErrText.setText(errText);
                                }
                            }


                        }
                    });
                    //设置为高精度定位模式
                    mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
                    //设置定位间隔,单位毫秒,默认为2000ms，最低1000ms。
//                    mLocationOption.setInterval(3000);
                    //设置是否允许模拟位置,默认为false，不允许模拟位置
                    mLocationOption.setMockEnable(true);
                    //设置定位参数
                    mlocationClient.setLocationOption(mLocationOption);
                    // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
                    // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
                    // 在定位结束后，在合适的生命周期调用onDestroy()方法
                    // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
                    mlocationClient.startLocation();
                }
            }

            @Override
            public void deactivate() {
                mListener = null;
                if (mlocationClient != null) {
                    mlocationClient.stopLocation();
                    mlocationClient.onDestroy();
                }
                mlocationClient = null;
            }
        });// 设置定位监听
        aMap.getUiSettings().setMyLocationButtonEnabled(true);// 设置默认定位按钮是否显示
        aMap.getUiSettings().setZoomControlsEnabled(false);// 设置了地图是否允许显示缩放按钮
        aMap.setMyLocationEnabled(true);// 设置为true表示显示定位层并可触发定位，false表示隐藏定位层并不可触发定位，默认是false
        // aMap.setMyLocationType()
    }

    /**
     * 两个位置是否不一样
     *
     * @return
     */
    private boolean isDifferent(LatLng oldLatLng, LatLng newLatLng) {
//        return oldLatLng.latitude - newLatLng.latitude != 0 && oldLatLng.longitude - newLatLng.longitude != 0;
        return AMapUtils.calculateLineDistance(oldLatLng, newLatLng) > 1;
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        countDownTimer.cancel();
        //在activity执行onDestroy时执行mMapView.onDestroy()，销毁地图
        mMapView.onDestroy();
        if (null != mlocationClient) {
            mlocationClient.onDestroy();
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        //在activity执行onResume时执行mMapView.onResume ()，重新绘制加载地图
        mMapView.onResume();
        if (mSensorHelper != null) {
            mSensorHelper.registerSensorListener();
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        //在activity执行onPause时执行mMapView.onPause ()，暂停地图的绘制
        mMapView.onPause();
        if (mSensorHelper != null) {
            mSensorHelper.unRegisterSensorListener();
            mSensorHelper.setCurrentMarker(null);
            mSensorHelper = null;
        }
        mFirstFix = false;
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        //在activity执行onSaveInstanceState时执行mMapView.onSaveInstanceState (outState)，保存地图当前的状态
        mMapView.onSaveInstanceState(outState);
    }


    private void addCircle(LatLng latlng, double radius) {
        CircleOptions options = new CircleOptions();
        options.strokeWidth(1f);
        options.fillColor(FILL_COLOR);
        options.strokeColor(STROKE_COLOR);
        options.center(latlng);
        options.radius(radius);
        mCircle = aMap.addCircle(options);
    }

    private void addMarker(LatLng latlng) {
        if (mLocMarker != null) {
            return;
        }
        Bitmap bMap = BitmapFactory.decodeResource(this.getResources(),
                R.mipmap.navi_map_gps_locked);
        BitmapDescriptor des = BitmapDescriptorFactory.fromBitmap(bMap);

//		BitmapDescriptor des = BitmapDescriptorFactory.fromResource(R.drawable.navi_map_gps_locked);
        MarkerOptions options = new MarkerOptions();
        options.icon(des);
        options.anchor(0.5f, 0.5f);
        options.position(latlng);
        mLocMarker = aMap.addMarker(options);
        mLocMarker.setTitle(LOCATION_MARKER_FLAG);
    }

    /**
     * 绘制一段直线
     *
     * @param aMap
     * @param oldData
     * @param newData
     */
    private void addLinePointAndDraw(AMap aMap, final LatLng oldData, final LatLng newData) {
        // 绘制一个大地曲线
        aMap.addPolyline((new PolylineOptions())
                .add(oldData, newData)
                .geodesic(true).color(Color.GREEN));

        latLngs.add(newData);
        totalDistance += AMapUtils.calculateLineDistance(oldData, newData);
        LogUtils.i("totalDistance: " + totalDistance);

        updateUi(totalTime, totalDistance, 1);
    }

    /**
     * 更新UI
     *
     * @param second    秒
     * @param destance  以米为单位
     * @param sportType 运动类型
     */
    private void updateUi(int second, int destance, int sportType) {
        int vQianka = 0;
        if (sportType == 1) {
            vQianka = destance * 10;
        } else if (sportType == 2) {
            vQianka = destance * 10;
        }

        float vGongli = MathUtils.get2Point1(destance * 1.0f / 1000, 2);
        float vSudu = second / vGongli * 60;

        tvQianka.setText(vQianka + "");
        tvDistance.setText(vGongli + "");
        tvGongli.setText(vGongli + "");
        tvShudu.setText(vSudu + "");

    }

}

LuJingActivity.java

package com.example.kuby.myapplication.map;

import android.graphics.Color;
import android.os.Handler;
import android.os.Parcelable;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

import com.amap.api.maps2d.AMap;
import com.amap.api.maps2d.AMapException;
import com.amap.api.maps2d.AMapUtils;
import com.amap.api.maps2d.CameraUpdate;
import com.amap.api.maps2d.CameraUpdateFactory;
import com.amap.api.maps2d.MapView;
import com.amap.api.maps2d.model.BitmapDescriptorFactory;
import com.amap.api.maps2d.model.LatLng;
import com.amap.api.maps2d.model.LatLngBounds;
import com.amap.api.maps2d.model.MarkerOptions;
import com.amap.api.maps2d.model.PolylineOptions;
import com.example.kuby.myapplication.R;
import com.example.kuby.myapplication.StepAndGaoDeMapActivity;
import com.example.kuby.myapplication.utils.LogUtils;

import java.util.ArrayList;

public class LuJingActivity extends AppCompatActivity {

    private MapView mMapView;
    private AMap aMap;
    private MarkerOptions markerOption;
    private LatLng latLngEnd;
    private LatLng latLngStart;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_lu_jing);

        //获取地图控件引用
        mMapView = (MapView) findViewById(R.id.map);
        //在activity执行onCreate时执行mMapView.onCreate(savedInstanceState)，创建地图
        mMapView.onCreate(savedInstanceState);

        init();

        initValue();
    }

    /**
     * 方法必须重写
     */
    @Override
    protected void onResume() {
        super.onResume();
        mMapView.onResume();
        aMap.moveCamera(CameraUpdateFactory.zoomTo(19));
        mMapView.postDelayed(new Runnable() {
            @Override
            public void run() {
                controlMapView();
            }
        }, 500);
    }

    /**
     * 方法必须重写
     */
    @Override
    protected void onPause() {
        super.onPause();
        mMapView.onPause();
    }

    /**
     * 方法必须重写
     */
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        mMapView.onSaveInstanceState(outState);
    }

    /**
     * 方法必须重写
     */
    @Override
    protected void onDestroy() {
        super.onDestroy();
        mMapView.onDestroy();
    }

    private void initValue() {
        ArrayList<LatLng> listPosition = getIntent().getParcelableArrayListExtra(StepAndGaoDeMapActivity.POSITION_LIST);
        if (listPosition == null || listPosition.size() < 2) {
            return;
        }
        latLngEnd = listPosition.get(listPosition.size() - 1);
        latLngStart = listPosition.get(0);
        LatLng latLngStart1 = listPosition.get(1);
        addLinePointAndDraw(aMap, latLngStart, latLngStart1);

        LatLng star = latLngStart1;
        LatLng star1 = null;
        for (int i = 2; i < listPosition.size(); i++) {
            star1 = listPosition.get(i);
            addLinePointAndDraw(aMap, star, star1);
            star = star1;
        }


        addMarkersToMap(latLngStart, R.mipmap.amap_start);
        addMarkersToMap(latLngEnd, R.mipmap.amap_end);
    }

    /**
     * 控制视图大小及位置
     */
    private void controlMapView() {
        //1.将视图移动到指定的位置,并且设置缩放级别
        /*aMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latLngStart, 14));//移动到自定的点*/

        //2.将视图自动拓展到包含这几个点的地方
        LatLngBounds bounds = new LatLngBounds.Builder().include(latLngStart).include(latLngEnd).build();
        aMap.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, 1));
    }

    private void init() {
        if (aMap == null) {
            aMap = mMapView.getMap();
            setUpMap();
        }

    }

    private void setUpMap() {

    }

    /**
     * 绘制一段直线
     *
     * @param aMap
     * @param oldData
     * @param newData
     */
    private void addLinePointAndDraw(AMap aMap, final LatLng oldData, final LatLng newData) {
        // 绘制一个大地曲线
        aMap.addPolyline((new PolylineOptions())
                .add(oldData, newData)
                .geodesic(true).color(Color.GREEN));

    }


    /**
     * 在地图上添加marker
     */
    private void addMarkersToMap(LatLng latlng,int iconId) {

        markerOption = new MarkerOptions().icon(BitmapDescriptorFactory
                .fromResource(iconId))
                .position(latlng)
                .draggable(true);
        aMap.addMarker(markerOption);
    }

}

上面为这2个Activity的源码，部分难点已经在注释中有说明，有问题的话可以留言，谢谢！需要源码的可以留下邮箱。

下面重点展示一些重要的代码：

1、绘制一条曲线

/**
     * 绘制一段直线
     *
     * @param aMap
     * @param oldData
     * @param newData
     */
    private void addLinePointAndDraw(AMap aMap, final LatLng oldData, final LatLng newData) {
        // 绘制一个大地曲线
        aMap.addPolyline((new PolylineOptions())
                .add(oldData, newData)
                .geodesic(true).color(Color.GREEN));

    }

2、在地图上添加一个marker标记

/**
     * 绘制一段直线
     *
     * @param aMap
     * @param oldData
     * @param newData
     */
    private void addLinePointAndDraw(AMap aMap, final LatLng oldData, final LatLng newData) {
        // 绘制一个大地曲线
        aMap.addPolyline((new PolylineOptions())
                .add(oldData, newData)
                .geodesic(true).color(Color.GREEN));

    }

3、控制视图的缩放级别

    /**
     * 控制视图大小及位置
     */
    private void controlMapView() {
        //1.将视图移动到指定的位置,并且设置缩放级别
        /*aMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latLngStart, 14));//移动到自定的点*/

        //2.将视图自动拓展到包含这几个点的地方
        LatLngBounds bounds = new LatLngBounds.Builder().include(latLngStart).include(latLngEnd).build();
        aMap.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, 1));
    }

4、设置定位标记能转动方向呢(高德地图上面的官方文档并不能实现,后来是冲demo里抠出来的方法)

首先我们需要一个SensorEventHelper类

package com.example.kuby.myapplication.map;

import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.view.Display;
import android.view.Surface;
import android.view.WindowManager;

import com.amap.api.maps2d.model.Marker;

public class SensorEventHelper implements SensorEventListener {

	private SensorManager mSensorManager;
	private Sensor mSensor;
	private long lastTime = 0;
	private final int TIME_SENSOR = 100;
	private float mAngle;
	private Context mContext;
	private Marker mMarker;

	public SensorEventHelper(Context context) {
		mContext = context;
		mSensorManager = (SensorManager) context
				.getSystemService(Context.SENSOR_SERVICE);
		mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);

	}

	public void registerSensorListener() {
		mSensorManager.registerListener(this, mSensor,
				SensorManager.SENSOR_DELAY_NORMAL);
	}

	public void unRegisterSensorListener() {
		mSensorManager.unregisterListener(this, mSensor);
	}

	public void setCurrentMarker(Marker marker) {
		mMarker = marker;
	}

	@Override
	public void onAccuracyChanged(Sensor sensor, int accuracy) {
		// TODO Auto-generated method stub

	}

	@Override
	public void onSensorChanged(SensorEvent event) {
		if (System.currentTimeMillis() - lastTime < TIME_SENSOR) {
			return;
		}
		switch (event.sensor.getType()) {
		case Sensor.TYPE_ORIENTATION: {
			float x = event.values[0];
			x += getScreenRotationOnPhone(mContext);
			x %= 360.0F;
			if (x > 180.0F)
				x -= 360.0F;
			else if (x < -180.0F)
				x += 360.0F;
			
			if (Math.abs(mAngle - x) < 3.0f) {
				break;
			}
			mAngle = Float.isNaN(x) ? 0 : x;
			if (mMarker != null) {
				mMarker.setRotateAngle(360-mAngle);
			}
			lastTime = System.currentTimeMillis();
		}
		}

	}

	public static int getScreenRotationOnPhone(Context context) {
		final Display display = ((WindowManager) context
				.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();

		switch (display.getRotation()) {
		case Surface.ROTATION_0:
			return 0;

		case Surface.ROTATION_90:
			return 90;

		case Surface.ROTATION_180:
			return 180;

		case Surface.ROTATION_270:
			return -90;
		}
		return 0;
	}
}

使用

 // 自定义系统定位小蓝点
        MyLocationStyle myLocationStyle = new MyLocationStyle();
        myLocationStyle.myLocationIcon(BitmapDescriptorFactory
                .fromResource(R.mipmap.location_marker));// 设置小蓝点的图标
        myLocationStyle.strokeColor(Color.BLACK);// 设置圆形的边框颜色
        myLocationStyle.radiusFillColor(Color.argb(100, 0, 0, 180));// 设置圆形的填充颜色
        // myLocationStyle.anchor(int,int)//设置小蓝点的锚点
        myLocationStyle.strokeWidth(1.0f);// 设置圆形的边框粗细

mSensorHelper = new SensorEventHelper(this);
        if (mSensorHelper != null) {
            mSensorHelper.registerSensorListener();
        }