android 开发我的高德地图代码例子

下载高德地图依赖库和相关注册方式，请查看高德开发者网站：http://lbs.amap.com/api/android-sdk/summary 点击打开链接

高德地图坐标拾取器：http://lbs.amap.com/console/show/picker 点击打开链接

使用 keytool（jdk自带工具）获取SHA1

，按照如下步骤进行操作：

1.运行进入控制台。

2.在弹出的控制台窗口中输入 cd .android 定位到 .android 文件夹。

3.继续在控制台输入命令。

debug.keystore：命令为：keytool -list -v -keystore debug.keystore

自定义的 keystore：命令为：keytool -list -v -keystore apk的keystore

如下所示：

提示输入密钥库密码，编译器提供的debug keystore默认密码是 android，自定义签名文件的密码请自行填写。输入密钥后回车（如果没设置密码，可直接回车），此时可在控制台显示的信息中获取 SHA1 值，如下图所示：

说明：keystore 文件为 Android 签名证书文件。

例子1：

package com.example.lenovo.mydemoapp;

import android.content.Intent;

import android.graphics.Point;

import android.os.PersistableBundle;

import android.support.annotation.Nullable;

import android.support.v7.app.AppCompatActivity;

import android.os.Bundle;

import android.util.Log;

import android.view.View;

import android.view.ViewGroup;

import android.widget.SeekBar;

import android.widget.TextView;

import android.widget.Toast;

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.maps.AMap;

import com.amap.api.maps.AMapUtils;

import com.amap.api.maps.CameraUpdateFactory;

import com.amap.api.maps.LocationSource;

import com.amap.api.maps.MapView;

import com.amap.api.maps.UiSettings;

import com.amap.api.maps.model.CameraPosition;

import com.amap.api.maps.model.LatLng;

import java.text.SimpleDateFormat;

import java.util.Date;

/*

name：编辑安全区

time：2018-06-09 11:32:22

Can Enter：1.安全区信息确认 SafeAreaConfirmation

return：1.高德地图的经纬度坐标值  2.围栏的半径大小

returnActivity：1.安全区

 */

// LocationSource 定位按键的监听接口

public class EditSafeArea extends AppCompatActivity implements LocationSource,AMap.OnCameraChangeListener,AMapLocationListener {

    private SeekBar mSeekBar ;

    //半径显示的文本View

    private TextView mRadiusValue;

    private View mEditSafeAreaMapFence;

    //下一步

    private TextView mEditSafeAreaTheNextStepText;

    //aMap 地图对象

    private AMap aMap;

    //地图视图

    private MapView mapView;

    //声明AMapLocationClient 地图位置客户端 对象，定位发起端

    private AMapLocationClient mLocationClient = null;

    //声明mLocationOption  地图位置客户端选项 对象，定位参数  `

    public AMapLocationClientOption mLocationOption = null;

    //声明mListener对象，定位监听器

    private OnLocationChangedListener mListener = null;

    //标识，用于判断是否只显示一次定位信息和用户重新定位

    private boolean isFirstLoc = true;

    private AMapLocation aMapLocation ;

    private int mRadius;

    private LatLng mLatlng;

    private final String LATITUDE_KEY = "latitude_value";

    private final String LONGITUDE_KEY = "longitude_value";

    private final String RADIUS_KEY = "radius_value";

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.edit_safe_area);

        //围栏

        mEditSafeAreaMapFence = (View)findViewById(R.id.EditSafeArea_MapFence);

        //拖动条

        mSeekBar = (SeekBar)findViewById(R.id.EditSafeArea_SeekBar);

        //半径显示文本

        mRadiusValue = (TextView)findViewById(R.id.EditSafeArea_radius_value);

        //下一步

        mEditSafeAreaTheNextStepText = (TextView)findViewById(R.id.EditSafeArea_TheNextStep_text);

        //获取地图控件

        mapView = (MapView)findViewById(R.id.EditSafeArea_MapView);

        //在activity执行onCreate时执行mMapView.onCreate(savedInstanceState)，实现地图生命周期管理

        mapView.onCreate(savedInstanceState);

        if(aMap == null){

            //创建地图对象

            aMap = mapView.getMap();

            //创建UI设置器

            UiSettings settings = aMap.getUiSettings();

            //地点变化监听器

            aMap.setLocationSource(this);

            //当前镜头变化监听器

            aMap.setOnCameraChangeListener(this);

            // 是否显示定位按钮

            settings.setMyLocationButtonEnabled(true);

            //定位图标是否可以点击

            aMap.setMyLocationEnabled(true);

        }

        //开始定位

        location();

        //设置拖动条默认值

        mSeekBar.setProgress(0);

        //设置拖动条默认值的显示 ，因为默认是400 所以这里添加400

        mRadiusValue.setText(Integer.toString(mSeekBar.getProgress()+400));

        //显示默认围栏的大小

        mEditSafeAreaMapFence.setLayoutParams(setFence());

        //拖动条监听

        mSeekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {

            @Override

            public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {

                //拖动条拖动后更新文本值

                mRadiusValue.setText(Integer.toString(progress+400));

                //更新围栏的范围

                mEditSafeAreaMapFence.setLayoutParams(setFence());

            }

            @Override

            public void onStartTrackingTouch(SeekBar seekBar) {

            }

            @Override

            public void onStopTrackingTouch(SeekBar seekBar) {

            }

        });

        //下一步监听

        mEditSafeAreaTheNextStepText.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                Intent intent = new Intent(EditSafeArea.this,SafeAreaConfirmation.class);

                if(mLatlng == null || mLatlng == null  || mRadius == 0 ){

                    Toast.makeText(EditSafeArea.this,"没有定位成功",Toast.LENGTH_SHORT).show();

                }else {

                    intent.putExtra(LATITUDE_KEY,mLatlng.latitude);

                    intent.putExtra(LONGITUDE_KEY,mLatlng.longitude);

                    intent.putExtra(RADIUS_KEY,mRadius);

                    Log.e("EditSafeArea","传出的mLatlng是："+mLatlng.latitude);

                    Log.e("EditSafeArea","传出的longitude是："+mLatlng.longitude);

                    Log.e("EditSafeArea","传出的半径值是："+mRadius);

                    startActivity(intent);

                }

            }

        });

    }

    private void location() {

        //初始化定位

        mLocationClient = new AMapLocationClient(getApplicationContext());

        //设置定位按键的监听

        mLocationClient.setLocationListener(this);

        //初始化定位参数  mLocationOption 定位的参数设置

        mLocationOption = new AMapLocationClientOption();

        //设置定位模式为Hight_Accuracy高精度模式，Battery_Saving为低功耗模式，Device_Sensors是仅设备模式

        mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);

        //设置是否返回地址信息（默认返回地址信息）

        mLocationOption.setNeedAddress(true);

        //设置是否只定位一次,默认为false

        mLocationOption.setOnceLocation(true);

        //设置是否强制刷新WIFI，默认为强制刷新

        mLocationOption.setWifiActiveScan(true);

        //设置是否允许模拟位置,默认为false，不允许模拟位置

        mLocationOption.setMockEnable(false);

        //设置定位间隔,单位毫秒,默认为2000ms

        mLocationOption.setInterval(5000);

        //给定位客户端对象设置定位参数

        mLocationClient.setLocationOption(mLocationOption);

        //启动定位

        mLocationClient.startLocation();

    }

    //因为地图的生命周期管理必须要与活动的生命周期管理捆绑，所以必须重写方法

    @Override

    protected void onDestroy() {

        super.onDestroy();

        mLocationClient.stopLocation();//停止定位

        mLocationClient.onDestroy();//销毁地图

    }

    //必须重写的方法

    @Override

    protected void onResume() {

        super.onResume();

        //重新恢复地图

        mapView.onResume();

    }

    //必须重写的方法

    @Override

    protected void onPause() {

        super.onPause();

        //暂停地图

        mapView.onPause();

    }

    //必须重写的方法

    @Override

    public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {

        super.onSaveInstanceState(outState, outPersistentState);

        mapView.onSaveInstanceState(outState);

    }

    /*

    定位参数回调   这个方法还有一个属性：如果之前已经定位了，并且添加了定位图标，那么每次手动点击定位按键回调这个方法

    ，就会在地图上执行一次自动回到定位点上

     */

    @Override

    public void onLocationChanged(AMapLocation aMapLocation) {

        this.aMapLocation = aMapLocation;

        if (aMapLocation != null) {

            if (aMapLocation.getErrorCode() == 0) {

                //定位成功回调信息，设置相关消息

                aMapLocation.getLocationType();//获取当前定位结果来源，如网络定位结果，详见官方定位类型表

                aMapLocation.getLatitude();//获取纬度

                aMapLocation.getLongitude();//获取经度

                aMapLocation.getAccuracy();//获取精度信息

                SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

                Date date = new Date(aMapLocation.getTime());

                df.format(date);//定位时间

                aMapLocation.getAddress();//地址，如果option中设置isNeedAddress为false，则没有此结果，网络定位结果中会有地址信息，GPS定位不返回地址信息。

                aMapLocation.getCountry();//国家信息

                aMapLocation.getProvince();//省信息

                aMapLocation.getCity();//城市信息

                aMapLocation.getDistrict();//城区信息

                aMapLocation.getStreet();//街道信息

                aMapLocation.getStreetNum();//街道门牌号信息

                aMapLocation.getCityCode();//城市编码

                aMapLocation.getAdCode();//地区编码

                LatLng latLng = new LatLng(aMapLocation.getLatitude(),aMapLocation.getLongitude());

                if (isFirstLoc) {

                    //设置缩放级别    moveCamera 移动相机   CameraUpdateFactory 相机更新制作  zoomBy 放大

                    aMap.moveCamera(CameraUpdateFactory.zoomTo(17));

                    //将地图移动到定位点，仅仅是将地图位置移动到定位点

                    aMap.moveCamera(CameraUpdateFactory.changeLatLng(new LatLng(aMapLocation.getLatitude(), aMapLocation.getLongitude())));

                    //获取定位信息

                    StringBuffer buffer = new StringBuffer();

                    buffer.append(aMapLocation.getCountry() + ""

                            + aMapLocation.getProvince() + ""

                            + aMapLocation.getCity() + ""

                            + aMapLocation.getProvince() + ""

                            + aMapLocation.getDistrict() + ""

                            + aMapLocation.getStreet() + ""

                            + aMapLocation.getStreetNum());

                    Toast.makeText(getApplicationContext(), buffer.toString(), Toast.LENGTH_LONG).show();

                    isFirstLoc = false;

                    Log.e("EditSafeArea","定位后的布尔值："+isFirstLoc);

                }

             } else {

                //显示错误信息ErrCode是错误码，errInfo是错误信息，详见错误码表。

                Log.e("AmapError", "location Error, ErrCode:"

                        + aMapLocation.getErrorCode() + ", errInfo:"

                        + aMapLocation.getErrorInfo());

                Toast.makeText(getApplicationContext(), "定位失败", Toast.LENGTH_LONG).show();

             }

        }

    }

    //定位按键启动 ，点击后此处会重新运行一次定位和定位回调 并且返回定位回调

    @Override

    public void activate(OnLocationChangedListener onLocationChangedListener) {

        Log.e("EditSafeArea","定位按键启动");

        //监听    onLocationChangedListener 定位位置变化监听器

        aMap.clear();

        aMap.moveCamera(CameraUpdateFactory.changeLatLng(new LatLng(aMapLocation.getLatitude(), aMapLocation.getLongitude())));

        mListener = onLocationChangedListener;

    }

    //定位按键完成关闭后回调的方法

    @Override

    public void deactivate() {

        mListener = null;

    }

    //地图镜头有动的情况下回调

    @Override

    public void onCameraChange(CameraPosition cameraPosition) {

        mLatlng = cameraPosition.target;

        mEditSafeAreaMapFence.setLayoutParams(setFence());

        }

    //地图镜头不动的回调

    @Override

    public void onCameraChangeFinish(CameraPosition cameraPosition) {

        mLatlng = cameraPosition.target;

        LatLng latLng  = cameraPosition.target;

    }

    //设置围栏的方法

    public ViewGroup.LayoutParams setFence(){

        mRadius = Integer.parseInt(mRadiusValue.getText().toString());

        //得到手机屏幕上的一个坐标

        Point point = new Point();

        point.x = 0;

        point.y = 0;

        //得到手机屏幕上的另外一个坐标

        Point point1 = new Point();

        point1.x = 0;

        point1.y = 200;

        //根据坐标获取地图上对应经纬

        LatLng latLng = aMap.getProjection().fromScreenLocation(point);

        LatLng latLng1 = aMap.getProjection().fromScreenLocation(point1);

        Log.e("EditSafeArea","latLng_latitude:"+latLng.latitude+"latLng_longitude:"+latLng.longitude);

        Log.e("EditSafeArea","latLng1_latitude:"+latLng1.latitude+"latLng1_longitude:"+latLng1.longitude);

        //根据2组经纬度计算之间的直线长度，单位是米

        float distance = AMapUtils.calculateLineDistance(latLng,latLng1);

        Log.e("EditSafeArea","distance:"+distance);

        //创建布局参数

        ViewGroup.LayoutParams layoutParams;

        layoutParams = mEditSafeAreaMapFence.getLayoutParams();

        //根据比例计算出围栏需要对应的大小

        int d = (int)(200 * mRadius / distance);

        //导入大小值  加200是为了在 安全区信息确认 的围栏大小显示统一，安全区信息确认的围栏大小显示是准确值

        layoutParams.width = d+200;

        layoutParams.height = d+200;

        return  layoutParams;

    }

}

例子2：

package com.example.lenovo.mydemoapp;

import android.content.Intent;

import android.graphics.Color;

import android.os.PersistableBundle;

import android.support.v7.app.AppCompatActivity;

import android.os.Bundle;

import android.util.Log;

import android.view.View;

import android.widget.Button;

import android.widget.EditText;

import android.widget.Toast;

import com.amap.api.location.AMapLocationClient;

import com.amap.api.location.AMapLocationClientOption;

import com.amap.api.location.AMapLocationListener;

import com.amap.api.maps.AMap;

import com.amap.api.maps.CameraUpdateFactory;

import com.amap.api.maps.MapView;

import com.amap.api.maps.UiSettings;

import com.amap.api.maps.model.CameraPosition;

import com.amap.api.maps.model.CircleOptions;

import com.amap.api.maps.model.LatLng;

/*

name：安全区信息确认

time：2018-06-09 11:32:22

Can Enter：1.保存 （返回安全区SafePlace）

return：1.高德地图坐标经纬度 2.围栏的半径 3.安全区名称

returnActivity：SafePlace

 */

public class SafeAreaConfirmation extends AppCompatActivity {

    private MapView mapView;

    private AMap aMap;

    private EditText mSafeAreaConfirmationEditText;

    private Button mSafeAreaConfirmationSave;

    //地图定位客户端 对象.定位发起端口

    private AMapLocationClient mLocationClient;

    //  地图位置客户端选项 对象，定位参数  `

    private AMapLocationClientOption mLocationOption;

    //

    private int mRadius ;

    private double mLatitude;

    private double mLongitude;

    //传入/传出值的key

    private final String LATITUDE_KEY = "latitude_value";

    private final String LONGITUDE_KEY = "longitude_value";

    private final String RADIUS_KEY = "radius_value";

    private final String NAME_KEY = "name_value";

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_safe_area_confirmation);

        mSafeAreaConfirmationEditText = (EditText)findViewById(R.id.SafeAreaConfirmation_EditText);

        mSafeAreaConfirmationSave = (Button)findViewById(R.id.SafeAreaConfirmation_save);

        mapView = (MapView)findViewById(R.id.SafeAreaConfirmation_MapView);

        mapView.onCreate(savedInstanceState);

        if(aMap == null){

            aMap = mapView.getMap();

            UiSettings uiSettings = aMap.getUiSettings();

            //不显示定位按键

            uiSettings.setMyLocationButtonEnabled(false);

            //不显示缩放图标

            uiSettings.setZoomControlsEnabled(false);

            //设置为不可以使用缩放手势

            uiSettings.setZoomGesturesEnabled(false);

            //设置为不可以使用滑动手势

            uiSettings.setScrollGesturesEnabled(false);

            //设置为不可以使用旋转手势

            uiSettings.setRotateGesturesEnabled(false);

            //定位图标不可以点击

            aMap.setMyLocationEnabled(false);

        }

        location();

        displayFence();

        //保存按键点击事件

        mSafeAreaConfirmationSave.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                if (mSafeAreaConfirmationEditText.getText().toString().equals("")){

                    Toast.makeText(SafeAreaConfirmation.this,"请输出安全区名称",Toast.LENGTH_SHORT).show();

                    Log.e("SafeAreaConfirmation","文本框中的值是空的");

                }else {

                    Log.e("SafeAreaConfirmation","文本框中的值是："+mSafeAreaConfirmationEditText.getText().toString());

                    Intent intent = new Intent(SafeAreaConfirmation.this,SafePlace.class);

                    intent.putExtra(LATITUDE_KEY,mLatitude);

                    intent.putExtra(LONGITUDE_KEY,mLongitude);

                    intent.putExtra(RADIUS_KEY,mRadius);

                    intent.putExtra(NAME_KEY,mSafeAreaConfirmationEditText.getText().toString());

                    startActivity(intent);

                }

            }

        });

    }

    //因为地图的生命周期管理必须要与活动的生命周期管理捆绑，所以必须重写方法

    @Override

    protected void onDestroy() {

        super.onDestroy();

        mLocationClient.stopLocation();//停止定位

        mLocationClient.onDestroy();//销毁地图

    }

    //必须重写的方法

    @Override

    protected void onResume() {

        super.onResume();

        //重新恢复地图

        mapView.onResume();

    }

    //必须重写的方法

    @Override

    protected void onPause() {

        super.onPause();

        //暂停地图

        mapView.onPause();

    }

    //必须重写的方法

    @Override

    public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {

        super.onSaveInstanceState(outState, outPersistentState);

        mapView.onSaveInstanceState(outState);

    }

    //初始化地图参数

    private void location() {

        //初始化定位

        mLocationClient = new AMapLocationClient(getApplicationContext());

        //初始化定位参数  mLocationOption 定位的参数设置

        mLocationOption = new AMapLocationClientOption();

        //设置定位模式为Hight_Accuracy高精度模式，Battery_Saving为低功耗模式，Device_Sensors是仅设备模式

        mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);

        //设置是否只定位一次,默认为false

        mLocationOption.setOnceLocation(true);

        //设置是否强制刷新WIFI，默认为强制刷新

        mLocationOption.setWifiActiveScan(true);

        //设置是否允许模拟位置,默认为false，不允许模拟位置

        mLocationOption.setMockEnable(false);

        //设置定位间隔,单位毫秒,默认为2000ms

        mLocationOption.setInterval(5000);

        //给定位客户端对象设置定位参数

        mLocationClient.setLocationOption(mLocationOption);

    }

    //在地图中画围栏

    public void displayFence(){

        Intent intent = getIntent();

        mLatitude = intent.getDoubleExtra(LATITUDE_KEY,0);

        mLongitude = intent.getDoubleExtra(LONGITUDE_KEY,0);

        mRadius = intent.getIntExtra(RADIUS_KEY,0);

        //圆选项

        CircleOptions circleOptions = new CircleOptions();

        if(mLatitude != 0 && mLongitude != 0 && mRadius != 0){

            LatLng latLng = new LatLng(mLatitude,mLongitude);

            aMap.moveCamera(CameraUpdateFactory.changeLatLng(latLng));

            //设置地图放大显示级别

            if (mRadius < 200){

                aMap.moveCamera(CameraUpdateFactory.zoomTo(17));

            }else if(mRadius < 400){

                aMap.moveCamera(CameraUpdateFactory.zoomTo(16));

            }else if (mRadius < 700){

                aMap.moveCamera(CameraUpdateFactory.zoomTo(15));

            }else if (mRadius <= 1300){

                aMap.moveCamera(CameraUpdateFactory.zoomTo(14));

            }

            // 导入坐标

            circleOptions.center(latLng);

            // 设置半径

            Log.e("SafeAreaConfirmation","radius is："+mRadius);

            circleOptions.radius(mRadius);

            // 设置画笔宽度

            circleOptions.strokeWidth(4);

            //画笔颜色

            circleOptions.strokeColor(Color.argb(255,0,140,237));

            //填色

            circleOptions.fillColor(Color.argb(50,99,184,255));

            aMap.addCircle(circleOptions);

        }else {

            Log.e("SafeAreaConfirmation","latitude and longitude and radius is empty");

        }

    }

}

地图上的标记自定义：

 //设置地图标记

    public void addMapMark(int position){

        MarkerOptions markerOption = new MarkerOptions();

        markerOption.position(listData.getLatLng());

        markerOption.title(listData.getName());

        markerOption.draggable(false);

        Bitmap bt = BitmapFactory.decodeFile(listData.getFilePath());

        if(bt != null){

            markerOption.icon(BitmapDescriptorFactory.fromBitmap(BitmapFactory

                    .decodeFile(listData.getFilePath())));

        }else {

            Log.e(TAG, "没有获取到头像，使用默认头像");

            markerOption.icon(BitmapDescriptorFactory.fromBitmap(BitmapFactory

                    .decodeResource(getResources(),R.mipmap.default_avatar1)));

        }

        aMap.addMarker(markerOption);

    }

根据坐标获得地址：

首先要在class里接口：

public class MainActivity extends BaseActivity implements GeocodeSearch.OnGeocodeSearchListener

然后传入坐标值

    /**

     * 得到地图地址信息

     * @param latLng 坐标值

     */

    public void getAddress(LatLng latLng){

        geocodeSearch = new GeocodeSearch(this);

        geocodeSearch.setOnGeocodeSearchListener(this);

        Log.e(TAG, "getAddress 坐标值:"+"latitude:" +latLng.latitude+"longitude:"+latLng.longitude);

        LatLonPoint latLonPoint = new LatLonPoint(latLng.latitude,latLng.longitude);

        RegeocodeQuery regeocodeQuery = new RegeocodeQuery(latLonPoint,200,GeocodeSearch.AMAP);//发生送坐标、范围、坐标系

        geocodeSearch.getFromLocationAsyn(regeocodeQuery);

    }

获得坐标的地图地址文本回调

@Override  //根据坐标返回文本地址的回调接口

    public void onRegeocodeSearched(RegeocodeResult regeocodeResult, int i) {

        //1000 是高德官方指定的成功的回返码

        if( i == 1000){

            Log.e(TAG, "onRegeocodeSearched回调码i： "+i );

            RegeocodeAddress regeocodeAddress = regeocodeResult.getRegeocodeAddress();

            address = regeocodeAddress.getFormatAddress();

            Log.e(TAG, "onRegeocodeSearched地址： "+mAddress);

            mAddress.setText(address);

        }else {

            Log.e(TAG, "onRegeocodeSearched回调码i： "+i );

        }

    }

    @Override

    public void onGeocodeSearched(GeocodeResult geocodeResult, int i) {

        //根据地址返回坐标的回调，不用到

    }