百度地图上定位自己所在的位置

一、运行效果图

二、核心代码

package com.itheima.baidumap74;

import com.baidu.mapapi.map.BaiduMap;
import com.baidu.mapapi.map.MapStatusUpdate;
import com.baidu.mapapi.map.MapStatusUpdateFactory;
import com.baidu.mapapi.map.MapView;
import com.baidu.mapapi.map.UiSettings;
import com.baidu.mapapi.model.LatLng;
import com.itheima.baidumap74.util.Utils;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.Gravity;
import android.widget.Toast;

public abstract class BaseActivity extends Activity {
	
	private static final String TAG = "BaseActivity";
	
	/** 黑马坐标（北京市海淀区东北旺南路45号）*/
	protected LatLng hmPos = new LatLng(40.050513, 116.30361);
	/** 传智坐标 */
	protected LatLng czPos = new LatLng(40.065817,116.349902);
	/** 天安门坐标 */
	protected LatLng tamPos = new LatLng(39.915112,116.403963);


	protected MapView mapView;
	protected BaiduMap baiduMap;

	// 这里加final是为了不让子类覆盖，原因是为了预防这里的一些类还没初始化的时候就被子类调用
	@Override
	protected final void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		//获取地图控件引用  
        mapView = (MapView) findViewById(R.id.bmapView); 
        
        baiduMap = mapView.getMap();	// 获取地图控制器
        
        // 1.	隐藏缩放按钮、比例尺
        // mapView.showScaleControl(false);	// 隐藏比例按钮，默认是显示的
        // mapView.showZoomControls(false);	// 隐藏缩放按钮，默认是显示的
        
        // 2.	获取获取最小（3）、最大缩放级别（20）
        float maxZoomLevel = baiduMap.getMaxZoomLevel(); // 获取地图最大缩放级别
        float minZoomLevel = baiduMap.getMinZoomLevel(); // 获取地图最小缩放级别
        Log.i(TAG, "minZoomLevel = " + minZoomLevel + ", maxZoomLevel" + maxZoomLevel);
        
		// 3.	设置地图中心点为黑马
        MapStatusUpdate mapStatusUpdate = MapStatusUpdateFactory.newLatLng(hmPos);
        baiduMap.setMapStatus(mapStatusUpdate);
        
        // 4.	设置地图缩放为15
        mapStatusUpdate = MapStatusUpdateFactory.zoomTo(15);
        baiduMap.setMapStatus(mapStatusUpdate);
        
        // 6.	获取地图Ui控制器：隐藏指南针
        // UiSettings uiSettings = baiduMap.getUiSettings();
        // uiSettings.setCompassEnabled(false);	//  不显示指南针
        
        init();
	}
	
	/** 这个方法让子类实现 */
	public abstract void init();
	
	/**
	 * 在屏幕中央显示一个Toast
	 * @param text
	 */
	public void showToast(CharSequence text) {
		Utils.showToast(this, text);
	}
	
	@Override  
	protected void onDestroy() {  
		super.onDestroy();  
		//在activity执行onDestroy时执行mMapView.onDestroy()，实现地图生命周期管理  
		mapView.onDestroy();  
	} 
	
	@Override  
	protected void onResume() {  
		super.onResume();  
		//在activity执行onResume时执行mMapView. onResume ()，实现地图生命周期管理  
		mapView.onResume();  
	}  
	
	@Override  
	protected void onPause() {  
		super.onPause();  
		//在activity执行onPause时执行mMapView. onPause ()，实现地图生命周期管理  
		mapView.onPause();  
	}  
}

package com.itheima.baidumap74;

import com.baidu.mapapi.map.CircleOptions;
import com.baidu.mapapi.map.Stroke;

public class CircelOverlayActivity extends BaseActivity {

	@Override
	public void init() {
		CircleOptions options = new CircleOptions();	// 创建一个圆形覆盖物的参数
		options.center(hmPos)	// 圆心
				.radius(1000)	// 半径
				.stroke(new Stroke(20, 0x55FF0000))// 线条宽度、颜色
				.fillColor(0x5500FF00);	// 圆的填充颜色
		baiduMap.addOverlay(options);	// 添加一个覆盖物
	}

}

package com.itheima.baidumap74;

import com.baidu.mapapi.SDKInitializer;
import com.itheima.baidumap74.util.Utils;

import android.app.ListActivity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;

public class DemoListActivity extends ListActivity {

	private BroadcastReceiver receiver;
	private ClassAndName[] datas = {
			new ClassAndName(HelloBaiduMapActivity.class, "HelloBaiduMap"),
			new ClassAndName(MapLayerActivity.class, "地图图层"),
			new ClassAndName(CircelOverlayActivity.class, "圆形覆盖物"),
			new ClassAndName(TextOverlayActivity.class, "文字覆盖物"),
			new ClassAndName(MarkerOverlayActivity.class, "标志覆盖物"),
			new ClassAndName(SearchInBoundActivity.class, "在范围内搜索"),
			new ClassAndName(SearchInCityActivity.class, "在城市内搜索"),
			new ClassAndName(SearchInNearbyActivity.class, "在周边内搜索"),
			new ClassAndName(DrivingSearchActivity.class, "驾车路线搜索"),
			new ClassAndName(TransitSearchActivity.class, "换乘路线搜索"),
			new ClassAndName(WalkingSearchActivity.class, "步行路线搜索"),
			new ClassAndName(LocationActivity.class, "定位"),
	};
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		registerSDKCheckReceiver();
		ArrayAdapter<ClassAndName> adapter = 
				new ArrayAdapter<DemoListActivity.ClassAndName>(this, android.R.layout.simple_list_item_1, datas);
		setListAdapter(adapter);
	}
	
	@Override
	protected void onListItemClick(ListView l, View v, int position, long id) {
		// 取出单击位置的ClassAndName
		ClassAndName classAndName = (ClassAndName) l.getItemAtPosition(position);
		startActivity(new Intent(this, classAndName.clazz));
	}
	
	
	class ClassAndName {
		/** 用于保存Activity的字节码 */
		public Class<?> clazz;
		/** 用于保存Activity对应的名字 */
		public String name;
		public ClassAndName(Class<?> cls, String name) {
			this.clazz = cls;
			this.name = name;
		}
		@Override
		public String toString() {
			return name;
		}
	}
	
	private void registerSDKCheckReceiver() {
		receiver = new BroadcastReceiver() {
			
			@Override
			public void onReceive(Context context, Intent intent) {
				String action = intent.getAction();
				if (SDKInitializer.SDK_BROADCAST_ACTION_STRING_NETWORK_ERROR.equals(action)) {
					Utils.showToast(DemoListActivity.this, "网络错误");
				} else if (SDKInitializer.SDK_BROADTCAST_ACTION_STRING_PERMISSION_CHECK_ERROR.equals(action)) {
					Utils.showToast(DemoListActivity.this, "key验证失败");
				}
			}
		};
		IntentFilter filter = new IntentFilter();
		// 监听网络错误
		filter.addAction(SDKInitializer.SDK_BROADCAST_ACTION_STRING_NETWORK_ERROR);
		// 监听百度地图sdk 的key是否正确
		filter.addAction(SDKInitializer.SDK_BROADTCAST_ACTION_STRING_PERMISSION_CHECK_ERROR);
		registerReceiver(receiver, filter);
	}
	
	@Override
	protected void onDestroy() {
		unregisterReceiver(receiver);
		super.onDestroy();
	}
}

package com.itheima.baidumap74;

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

import com.baidu.mapapi.overlayutil.DrivingRouteOverlay;
import com.baidu.mapapi.search.route.DrivingRouteLine;
import com.baidu.mapapi.search.route.DrivingRoutePlanOption;
import com.baidu.mapapi.search.route.DrivingRouteResult;
import com.baidu.mapapi.search.route.PlanNode;
import com.baidu.mapapi.search.route.TransitRouteResult;
import com.baidu.mapapi.search.route.WalkingRouteResult;

public class DrivingSearchActivity extends RoutePlanSearchBaseActivity {

	@Override
	public void routePlanSearchInit() {
		routePlanSearch.drivingSearch(getSearchParams());
	}
	
	private DrivingRoutePlanOption getSearchParams() {
		DrivingRoutePlanOption params = new DrivingRoutePlanOption();
		List<PlanNode> nodes = new ArrayList<PlanNode>();
		nodes.add(PlanNode.withCityNameAndPlaceName("北京市", "天安门"));
		params.from(PlanNode.withLocation(hmPos));	// 设置起点
		params.passBy(nodes);						// 设置途经点
		params.to(PlanNode.withLocation(czPos));	// 设置终点
		return params;
	}

	/** 获取驾车搜索结果的回调方法 */
	@Override
	public void onGetDrivingRouteResult(DrivingRouteResult result) {
		DrivingRouteOverlay overlay = new DrivingRouteOverlay(baiduMap);
		baiduMap.setOnMarkerClickListener(overlay);
		List<DrivingRouteLine> routeLines = result.getRouteLines();	// 获取到所有的搜索路线，最优化的路线会在集合的前面
		overlay.setData(routeLines.get(0));	// 把搜索结果设置到覆盖物
		overlay.addToMap();					// 把搜索结果添加到地图
		overlay.zoomToSpan();				// 把搜索结果在一个屏幕内显示完
	}

	/** 获取换乘（公交、地铁）搜索结果的回调方法 */
	@Override
	public void onGetTransitRouteResult(TransitRouteResult result) {
	}

	/** 获取步行搜索结果的回调方法 */
	@Override
	public void onGetWalkingRouteResult(WalkingRouteResult result) {
	}

}

package com.itheima.baidumap74;

import android.util.Log;
import android.view.KeyEvent;

import com.baidu.mapapi.map.MapStatus;
import com.baidu.mapapi.map.MapStatusUpdate;
import com.baidu.mapapi.map.MapStatusUpdateFactory;

public class HelloBaiduMapActivity extends BaseActivity {
	
	private static final String TAG = "HelloBaiduMapActivity";
	
	@Override
	public void init() {
		
	}

	
	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event) {
		// 5.	更新地图状态
		MapStatusUpdate mapStatusUpdate = null;
		switch (keyCode) {
		case KeyEvent.KEYCODE_1:
			// 		1)	缩小
			mapStatusUpdate = MapStatusUpdateFactory.zoomOut();
			break;
		case KeyEvent.KEYCODE_2:
			// 		2)	放大
			mapStatusUpdate = MapStatusUpdateFactory.zoomIn();
			break;
		case KeyEvent.KEYCODE_3:
			// 		3)	旋转（0 ~ 360），每次在原来的基础上再旋转30度
			MapStatus currentMapStatus = baiduMap.getMapStatus();	// 获取地图当前的状态
			float rotate = currentMapStatus.rotate + 30;
			Log.i(TAG, "rotate = " + rotate);
			MapStatus mapStatus = new MapStatus.Builder().rotate(rotate).build();
			mapStatusUpdate = MapStatusUpdateFactory.newMapStatus(mapStatus);
			
			break;
		case KeyEvent.KEYCODE_4:
			// 		4)	俯仰（0 ~ -45），每次在原来的基础上再俯仰-5度
			currentMapStatus = baiduMap.getMapStatus();	// 获取地图当前的状态
			float overlook = currentMapStatus.overlook - 5;
			Log.i(TAG, "overlook = " + overlook);
			mapStatus = new MapStatus.Builder().overlook(overlook).build();
			mapStatusUpdate = MapStatusUpdateFactory.newMapStatus(mapStatus);
			
			break;
		case KeyEvent.KEYCODE_5:
			// 		5)	移动
			mapStatusUpdate = MapStatusUpdateFactory.newLatLng(czPos);
			baiduMap.animateMapStatus(mapStatusUpdate, 2000);
			return super.onKeyDown(keyCode, event);
		}
		baiduMap.setMapStatus(mapStatusUpdate);
		return super.onKeyDown(keyCode, event);
	}

}

package com.itheima.baidumap74;
import java.util.List;

import android.util.Log;
import android.view.KeyEvent;

import com.baidu.location.BDLocation;
import com.baidu.location.BDLocationListener;
import com.baidu.location.LocationClient;
import com.baidu.location.LocationClientOption;
import com.baidu.location.LocationClientOption.LocationMode;
import com.baidu.location.Poi;
import com.baidu.mapapi.map.BitmapDescriptor;
import com.baidu.mapapi.map.BitmapDescriptorFactory;
import com.baidu.mapapi.map.MyLocationConfiguration;
import com.baidu.mapapi.map.MyLocationData;

public class LocationActivity extends BaseActivity {
	
	public LocationClient mLocationClient = null;
	public BDLocationListener myListener = new MyLocationListener();
	
	public class MyLocationListener implements BDLocationListener {
		 
		// 在这个方法里面接收定位结果
        @Override
        public void onReceiveLocation(BDLocation location) {
        	if (location != null) {
        		MyLocationData.Builder builder = new MyLocationData.Builder();
        		builder.accuracy(location.getRadius());		// 设置精度
        		builder.direction(location.getDirection());	// 设置方向
        		builder.latitude(location.getLatitude());	// 设置纬度
        		builder.longitude(location.getLongitude());	// 设置经度
				MyLocationData locationData = builder.build();
				baiduMap.setMyLocationData(locationData);	// 把定位数据显示到地图上
			}
        	
            //Receive Location
            StringBuffer sb = new StringBuffer(256);
            sb.append("time : ");
            sb.append(location.getTime());
            sb.append("\nerror code : ");
            sb.append(location.getLocType());
            sb.append("\nlatitude : ");
            sb.append(location.getLatitude());
            sb.append("\nlontitude : ");
            sb.append(location.getLongitude());
            sb.append("\nradius : ");
            sb.append(location.getRadius());
            if (location.getLocType() == BDLocation.TypeGpsLocation){// GPS定位结果
            	sb.append("\nspeed : ");
            	sb.append(location.getSpeed());// 单位：公里每小时
            	sb.append("\nsatellite : ");
            	sb.append(location.getSatelliteNumber());
            	sb.append("\nheight : ");
            	sb.append(location.getAltitude());// 单位：米
            	sb.append("\ndirection : ");
            	sb.append(location.getDirection());// 单位度
            	sb.append("\naddr : ");
            	sb.append(location.getAddrStr());
            	sb.append("\ndescribe : ");
            	sb.append("gps定位成功");

            } else if (location.getLocType() == BDLocation.TypeNetWorkLocation){// 网络定位结果
            	sb.append("\naddr : ");
            	sb.append(location.getAddrStr());
            	//运营商信息
            	sb.append("\noperationers : ");
            	sb.append(location.getOperators());
            	sb.append("\ndescribe : ");
            	sb.append("网络定位成功");
            } else if (location.getLocType() == BDLocation.TypeOffLineLocation) {// 离线定位结果
            	sb.append("\ndescribe : ");
            	sb.append("离线定位成功，离线定位结果也是有效的");
            } else if (location.getLocType() == BDLocation.TypeServerError) {
            	sb.append("\ndescribe : ");
            	sb.append("服务端网络定位失败，可以反馈IMEI号和大体定位时间到loc-bugs@baidu.com，会有人追查原因");
            } else if (location.getLocType() == BDLocation.TypeNetWorkException) {
            	sb.append("\ndescribe : ");
            	sb.append("网络不同导致定位失败，请检查网络是否通畅");
            } else if (location.getLocType() == BDLocation.TypeCriteriaException) {
            	sb.append("\ndescribe : ");
            	sb.append("无法获取有效定位依据导致定位失败，一般是由于手机的原因，处于飞行模式下一般会造成这种结果，可以试着重启手机");
            }
            sb.append("\nlocationdescribe : ");
            sb.append(location.getLocationDescribe());// 位置语义化信息
            List<Poi> list = location.getPoiList();// POI数据
            if (list != null) {
            	sb.append("\npoilist size = : ");
            	sb.append(list.size());
            	for (Poi p : list) {
            		sb.append("\npoi= : ");
            		sb.append(p.getId() + " " + p.getName() + " " + p.getRank());
            	}
            }
            Log.i("BaiduLocationApiDem", sb.toString());
        }
	}
	 
	@Override
	public void init() {
		mLocationClient = new LocationClient(getApplicationContext());     //声明LocationClient类
	    mLocationClient.registerLocationListener(myListener);    //注册监听函数
	    initLocation();
	    baiduMap.setMyLocationEnabled(true);	// 开启定位图层
	    setMyLocationConfigeration(MyLocationConfiguration.LocationMode.COMPASS);
	    mLocationClient.start();	// 开始定位
	}
	
	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event) {
		switch (keyCode) {
		case KeyEvent.KEYCODE_1:	// 罗盘态，显示定位方向圈，保持定位图标在地图中心
			setMyLocationConfigeration(MyLocationConfiguration.LocationMode.COMPASS);
			break;
		case KeyEvent.KEYCODE_2:	// 跟随态，保持定位图标在地图中心
			setMyLocationConfigeration(MyLocationConfiguration.LocationMode.FOLLOWING);
			break;
		case KeyEvent.KEYCODE_3:	// 普通态： 更新定位数据时不对地图做任何操作
			setMyLocationConfigeration(MyLocationConfiguration.LocationMode.NORMAL);
			break;

		default:
			break;
		}
		return super.onKeyDown(keyCode, event);
	}

	/** 设置定位图层的配置 */
	private void setMyLocationConfigeration(
			MyLocationConfiguration.LocationMode mode) {
		boolean enableDirection = true;	// 设置允许显示方向
	    BitmapDescriptor customMarker = BitmapDescriptorFactory.fromResource(R.drawable.icon_geo);	// 自定义定位的图标
	    MyLocationConfiguration config = new MyLocationConfiguration(mode, enableDirection, customMarker);
		baiduMap.setMyLocationConfigeration(config);
	}
	
	@Override
	protected void onDestroy() {
		mLocationClient.stop();		// 停止定位
		super.onDestroy();
	}
	private void initLocation(){
        LocationClientOption option = new LocationClientOption();
        option.setLocationMode(LocationMode.Hight_Accuracy);//可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
        option.setCoorType("bd09ll");//可选，默认gcj02，设置返回的定位结果坐标系
        int span= 5000;
        option.setScanSpan(span);//可选，默认0，即仅定位一次，设置发起定位请求的间隔需要大于等于1000ms才是有效的
        option.setIsNeedAddress(true);//可选，设置是否需要地址信息，默认不需要
        option.setOpenGps(true);//可选，默认false,设置是否使用gps
        option.setLocationNotify(true);//可选，默认false，设置是否当gps有效时按照1S1次频率输出GPS结果
        option.setIsNeedLocationDescribe(true);//可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
        option.setIsNeedLocationPoiList(true);//可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
        option.setIgnoreKillProcess(false);//可选，默认false，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认杀死
        option.SetIgnoreCacheException(false);//可选，默认false，设置是否收集CRASH信息，默认收集
        option.setEnableSimulateGps(false);//可选，默认false，设置是否需要过滤gps仿真结果，默认需要
        mLocationClient.setLocOption(option);
    }

}

package com.itheima.baidumap74;

import com.baidu.mapapi.map.BaiduMap;

import android.view.KeyEvent;

public class MapLayerActivity extends BaseActivity {

	@Override
	public void init() {
		
	}
	
	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event) {
		switch (keyCode) {
		case KeyEvent.KEYCODE_1:
			// 显示普通地图
			baiduMap.setMapType(BaiduMap.MAP_TYPE_NORMAL);
			baiduMap.setTrafficEnabled(false);
			break;
		case KeyEvent.KEYCODE_2:
			// 显示卫星图
			baiduMap.setMapType(BaiduMap.MAP_TYPE_SATELLITE);
			baiduMap.setTrafficEnabled(false);
			break;
		case KeyEvent.KEYCODE_3:
			// 交通图
			baiduMap.setTrafficEnabled(true);
			break;
		}
		return super.onKeyDown(keyCode, event);
	}

}

package com.itheima.baidumap74;

import android.view.View;
import android.widget.TextView;

import com.baidu.mapapi.map.BaiduMap.OnMarkerClickListener;
import com.baidu.mapapi.map.BaiduMap.OnMarkerDragListener;
import com.baidu.mapapi.map.BitmapDescriptor;
import com.baidu.mapapi.map.BitmapDescriptorFactory;
import com.baidu.mapapi.map.MapViewLayoutParams;
import com.baidu.mapapi.map.MapViewLayoutParams.ELayoutMode;
import com.baidu.mapapi.map.Marker;
import com.baidu.mapapi.map.MarkerOptions;
import com.baidu.mapapi.model.LatLng;

public class MarkerOverlayActivity extends BaseActivity {

	private View pop;
	private TextView tv_title;

	@Override
	public void init() {
		initMarker();
		baiduMap.setOnMarkerClickListener(mOnMarkerClickListener);
		baiduMap.setOnMarkerDragListener(mOnMarkerDragListener);
	}
	
	/** 标志拖动监听器 */
	OnMarkerDragListener mOnMarkerDragListener = new OnMarkerDragListener() {
		
		/** 标志开始拖动 */
		@Override
		public void onMarkerDragStart(Marker marker) {
			mapView.updateViewLayout(pop, createLayoutParams(marker.getPosition()));
		}
		
		/** 标志拖动结束 */
		@Override
		public void onMarkerDragEnd(Marker marker) {
			mapView.updateViewLayout(pop, createLayoutParams(marker.getPosition()));
		}
		
		/** 标志正在拖动 */
		@Override
		public void onMarkerDrag(Marker marker) {
			mapView.updateViewLayout(pop, createLayoutParams(marker.getPosition()));
		}
	};
	
	OnMarkerClickListener mOnMarkerClickListener = new OnMarkerClickListener() {

		@Override
		public boolean onMarkerClick(Marker marker) {
			// 显示一个泡泡
			if (pop == null) {
				pop = View.inflate(MarkerOverlayActivity.this, R.layout.pop, null);
				tv_title = (TextView) pop.findViewById(R.id.tv_title);
				mapView.addView(pop, createLayoutParams(marker.getPosition()));
			} else {
				mapView.updateViewLayout(pop, createLayoutParams(marker.getPosition()));
			}
			tv_title.setText(marker.getTitle());
			return true;
		}
	};

	/** 初始化标志 */
	private void initMarker() {
		MarkerOptions options = new MarkerOptions();
		BitmapDescriptor icon = BitmapDescriptorFactory.fromResource(R.drawable.icon_eat);
		options.position(hmPos)		// 位置
				.title("黑马")		// title
				.icon(icon)			// 图标
				.draggable(true);	// 设置图标可以拖动
		
		baiduMap.addOverlay(options);
		
		// 添加一个向北的标志
		options = new MarkerOptions().icon(icon)
				.title("向北")
				.position(new LatLng(hmPos.latitude + 0.001, hmPos.longitude))
				.draggable(true);
		baiduMap.addOverlay(options);

		// 添加一个向东的标志
		options = new MarkerOptions().icon(icon)
				.title("向东")
				.position(new LatLng(hmPos.latitude, hmPos.longitude + 0.001))
				.draggable(true);
		baiduMap.addOverlay(options);

		// 添加一个向西南的标志
		options = new MarkerOptions().icon(icon)
				.title("向西南")
				.position(new LatLng(hmPos.latitude - 0.001, hmPos.longitude - 0.001))
				.draggable(true);
		baiduMap.addOverlay(options);
	}

	/**
	 * 创建一个布局参数
	 * @param position
	 * @return
	 */
	private MapViewLayoutParams createLayoutParams(LatLng position) {
		MapViewLayoutParams.Builder buidler = new MapViewLayoutParams.Builder(); 
		buidler.layoutMode(ELayoutMode.mapMode);	// 指定坐标类型为经纬度
		buidler.position(position);		// 设置标志的位置
		buidler.yOffset(-25);			// 设置View往上偏移
		MapViewLayoutParams params = buidler.build();
		return params;
	}

}

package com.itheima.baidumap74;

import android.app.Application;

import com.baidu.mapapi.SDKInitializer;

public class MyApplication extends Application {

	@Override
	public void onCreate() {
		//在使用SDK各组件之前初始化context信息，传入ApplicationContext  
        //注意该方法要再setContentView方法之前实现  
        SDKInitializer.initialize(getApplicationContext()); 
	}
	
}

package com.itheima.baidumap74;

import com.baidu.mapapi.overlayutil.PoiOverlay;
import com.baidu.mapapi.search.core.PoiInfo;
import com.baidu.mapapi.search.core.SearchResult;
import com.baidu.mapapi.search.poi.OnGetPoiSearchResultListener;
import com.baidu.mapapi.search.poi.PoiResult;
import com.baidu.mapapi.search.poi.PoiSearch;

public abstract class PoiSearchBaseActivity extends BaseActivity implements OnGetPoiSearchResultListener{

	protected PoiSearch poiSearch;
	protected PoiOverlay poiOverlay;

	@Override
	public final void init() {
		// 因为其它搜索也需要这个实例，所以放在父类初始，这样的话子类就不需要再实例化
		poiSearch = PoiSearch.newInstance();
		poiSearch.setOnGetPoiSearchResultListener(this);
		
		poiOverlay = new PoiOverlay(baiduMap) {
			@Override
			public boolean onPoiClick(int index) {
				return PoiSearchBaseActivity.this.onPoiClick(index);
			}
		};
		baiduMap.setOnMarkerClickListener(poiOverlay);
		
		poiSearchInit();
	}
	
	/**
	 * 生成这个方法，是为了让子类可以覆盖
	 * @param index
	 * @return
	 */
	public boolean onPoiClick(int index) {
		PoiInfo poiInfo = poiOverlay.getPoiResult().getAllPoi().get(index);
		showToast(poiInfo.name + ", " + poiInfo.address);
		return true;
	}
	
	/** poi搜索的初始化代码写在这个方法 */
	public abstract void poiSearchInit();

	// 因为其它搜索结果的处理都是相同的，所以放在父类
	/** 获取兴趣点信息 */
	@Override
	public void onGetPoiResult(PoiResult result) {
		if (result == null || result.error != SearchResult.ERRORNO.NO_ERROR) {
			showToast("没有搜索到结果");
			return;
		}
		
		poiOverlay.setData(result);	// 把数据设置给覆盖物
		poiOverlay.addToMap();		// 把所有的数据的变成覆盖添加到BaiduMap
		poiOverlay.zoomToSpan();	// 把所有的搜索结果在一个屏幕内显示出来
	}

}

package com.itheima.baidumap74;

import com.baidu.mapapi.search.route.OnGetRoutePlanResultListener;
import com.baidu.mapapi.search.route.RoutePlanSearch;

public abstract class RoutePlanSearchBaseActivity extends BaseActivity implements OnGetRoutePlanResultListener {

	protected RoutePlanSearch routePlanSearch;

	@Override
	public void init() {
		routePlanSearch = RoutePlanSearch.newInstance();
		routePlanSearch.setOnGetRoutePlanResultListener(this);
		routePlanSearchInit();
	}
	
	/** 路径搜索初化代码写在这个方法 中*/
	public abstract void routePlanSearchInit();

}

package com.itheima.baidumap74;

import com.baidu.mapapi.model.LatLng;
import com.baidu.mapapi.model.LatLngBounds;
import com.baidu.mapapi.search.poi.PoiBoundSearchOption;
import com.baidu.mapapi.search.poi.PoiDetailResult;

public class SearchInBoundActivity extends PoiSearchBaseActivity {

	@Override
	public void poiSearchInit() {
		poiSearch.searchInBound(getSearchParams());
	}
	
	private PoiBoundSearchOption getSearchParams() {
		PoiBoundSearchOption params = new PoiBoundSearchOption();
		
		// 指定搜索范围，由一个西南点和一个东北点组成的范围
		LatLngBounds bounds = new LatLngBounds.Builder().include(new LatLng(40.048459,116.302072))
														.include(new LatLng(40.050675,116.304317)).build();
		params.bound(bounds);	// 指定搜索范围
		params.keyword("加油站");	// 指定搜索什么内容
		return params;
	}

	/** 获取兴趣点详情信息 */
	@Override
	public void onGetPoiDetailResult(PoiDetailResult result) {
		
	}

}

package com.itheima.baidumap74;

import android.view.KeyEvent;

import com.baidu.mapapi.search.core.PoiInfo;
import com.baidu.mapapi.search.core.SearchResult;
import com.baidu.mapapi.search.poi.PoiCitySearchOption;
import com.baidu.mapapi.search.poi.PoiDetailResult;
import com.baidu.mapapi.search.poi.PoiDetailSearchOption;

public class SearchInCityActivity extends PoiSearchBaseActivity {

	private int pageNum;

	@Override
	public void poiSearchInit() {
		poiSearch.searchInCity(getSearchParams());
		
	}
	
	@Override
	public boolean onPoiClick(int index) {
		// 当点击一个搜索出来的兴趣点的时候，再去搜索更详细的内容
		PoiInfo poiInfo = poiOverlay.getPoiResult().getAllPoi().get(index);
		poiSearch.searchPoiDetail(getSearchDetailParams(poiInfo.uid));
		return true;
	}
	
	private PoiDetailSearchOption getSearchDetailParams(String poiUid) {
		PoiDetailSearchOption params = new PoiDetailSearchOption();
		params.poiUid(poiUid);
		return params;
	}

	private PoiCitySearchOption getSearchParams() {
		PoiCitySearchOption params = new PoiCitySearchOption();
		params.city("北京");			// 指定在哪个城市内进行搜索
		params.keyword("加油站");		// 指定搜索的是什么内容
		params.pageCapacity(10);	// 设置一页获取10条数据
		params.pageNum(pageNum);	// 指定获取哪一页
		return params;
	}

	/** 获取到详情信息的回调方法 */
	@Override
	public void onGetPoiDetailResult(PoiDetailResult result) {
		if (result == null || result.error != SearchResult.ERRORNO.NO_ERROR) {
			showToast("没有搜索到详情信息");
			return ;
		}
		
		showToast(result.getShopHours() + ", " + result.getTelephone());
	}
	
	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event) {
		if (keyCode == KeyEvent.KEYCODE_1) {
			// 获取下一页数据
			pageNum++;
			poiSearch.searchInCity(getSearchParams());
		}
		return super.onKeyDown(keyCode, event);
	}

}

package com.itheima.baidumap74;

import com.baidu.mapapi.search.poi.PoiDetailResult;
import com.baidu.mapapi.search.poi.PoiNearbySearchOption;

/**
 * 在周边搜索
 * 
 *
 */
public class SearchInNearbyActivity extends PoiSearchBaseActivity {

	@Override
	public void poiSearchInit() {
		poiSearch.searchNearby(getSearchParams());
	}
	

	private PoiNearbySearchOption getSearchParams() {
		PoiNearbySearchOption params = new PoiNearbySearchOption();
		params.location(hmPos);	// 指定在哪个位置搜索
		params.radius(1000);	// 指定搜索范围
		params.keyword("建设银行");	// 指定搜索的内容
		return params;
	}


	/** 获取兴趣点详情信息 */
	@Override
	public void onGetPoiDetailResult(PoiDetailResult result) {
		
	}

}

package com.itheima.baidumap74;

import com.baidu.mapapi.map.TextOptions;

public class TextOverlayActivity extends BaseActivity {

	@Override
	public void init() {
		TextOptions options = new TextOptions();
		options.position(hmPos)			// 位置
				.text("黑马程序员")			// 文字内容
				.fontSize(20)			// 文字大小
				.fontColor(0XFF000000)	// 文字颜色
				.bgColor(0X55FF0000)	// 背景颜色
				.rotate(30);			// 旋转
		baiduMap.addOverlay(options);
	}

}

package com.itheima.baidumap74;

import java.util.List;

import com.baidu.mapapi.overlayutil.TransitRouteOverlay;
import com.baidu.mapapi.search.route.DrivingRouteResult;
import com.baidu.mapapi.search.route.PlanNode;
import com.baidu.mapapi.search.route.TransitRouteLine;
import com.baidu.mapapi.search.route.TransitRoutePlanOption;
import com.baidu.mapapi.search.route.TransitRoutePlanOption.TransitPolicy;
import com.baidu.mapapi.search.route.TransitRouteResult;
import com.baidu.mapapi.search.route.WalkingRouteResult;

/**
 * 换乘路线搜索（公交、地铁）
 * 
 *
 */
public class TransitSearchActivity extends RoutePlanSearchBaseActivity {

	@Override
	public void routePlanSearchInit() {
		routePlanSearch.transitSearch(getSearchParams());
	}
	
	private TransitRoutePlanOption getSearchParams() {
		TransitRoutePlanOption params = new TransitRoutePlanOption();
		params.city("北京");	// 设置在哪个城市内搜索
		params.policy(TransitPolicy.EBUS_TIME_FIRST);// 设置策略为：时间优先
		params.from(PlanNode.withLocation(hmPos));	// 设置起点
		params.to(PlanNode.withLocation(czPos));	// 设置终点
		return params;
	}

	/** 获取驾车搜索结果的回调方法 */
	@Override
	public void onGetDrivingRouteResult(DrivingRouteResult result) {
	}

	/** 获取换乘（公交、地铁）搜索结果的回调方法 */
	@Override
	public void onGetTransitRouteResult(TransitRouteResult result) {
		TransitRouteOverlay overlay = new TransitRouteOverlay(baiduMap);
		baiduMap.setOnMarkerClickListener(overlay);
		List<TransitRouteLine> routeLines = result.getRouteLines();	// 获取到所有的搜索路线，最优化的路线会在集合的前面
		overlay.setData(routeLines.get(0));	// 把搜索结果设置到覆盖物
		overlay.addToMap();					// 把搜索结果添加到地图
		overlay.zoomToSpan();				// 把搜索结果在一个屏幕内显示完
	}

	/** 获取步行搜索结果的回调方法 */
	@Override
	public void onGetWalkingRouteResult(WalkingRouteResult result) {
	}

}

package com.itheima.baidumap74;

import java.util.List;

import com.baidu.mapapi.overlayutil.TransitRouteOverlay;
import com.baidu.mapapi.overlayutil.WalkingRouteOverlay;
import com.baidu.mapapi.search.route.DrivingRouteResult;
import com.baidu.mapapi.search.route.PlanNode;
import com.baidu.mapapi.search.route.TransitRouteLine;
import com.baidu.mapapi.search.route.TransitRoutePlanOption;
import com.baidu.mapapi.search.route.WalkingRouteLine;
import com.baidu.mapapi.search.route.TransitRoutePlanOption.TransitPolicy;
import com.baidu.mapapi.search.route.TransitRouteResult;
import com.baidu.mapapi.search.route.WalkingRoutePlanOption;
import com.baidu.mapapi.search.route.WalkingRouteResult;

/**
 * 步行路线搜索
 * 
 *
 */
public class WalkingSearchActivity extends RoutePlanSearchBaseActivity {

	@Override
	public void routePlanSearchInit() {
		routePlanSearch.walkingSearch(getSearchParams());
	}
	
	private WalkingRoutePlanOption getSearchParams() {
		WalkingRoutePlanOption params = new WalkingRoutePlanOption();
		params.from(PlanNode.withLocation(hmPos));	// 设置起点
		params.to(PlanNode.withLocation(czPos));	// 设置终点
		return params;
	}


	/** 获取驾车搜索结果的回调方法 */
	@Override
	public void onGetDrivingRouteResult(DrivingRouteResult result) {
	}

	/** 获取换乘（公交、地铁）搜索结果的回调方法 */
	@Override
	public void onGetTransitRouteResult(TransitRouteResult result) {
	}

	/** 获取步行搜索结果的回调方法 */
	@Override
	public void onGetWalkingRouteResult(WalkingRouteResult result) {
		WalkingRouteOverlay overlay = new WalkingRouteOverlay(baiduMap);
		baiduMap.setOnMarkerClickListener(overlay);
		List<WalkingRouteLine> routeLines = result.getRouteLines();	// 获取到所有的搜索路线，最优化的路线会在集合的前面
		overlay.setData(routeLines.get(0));	// 把搜索结果设置到覆盖物
		overlay.addToMap();					// 把搜索结果添加到地图
		overlay.zoomToSpan();				// 把搜索结果在一个屏幕内显示完
	}

}

package com.itheima.baidumap74.util;

import android.content.Context;
import android.view.Gravity;
import android.widget.Toast;

public class Utils {

	/**
	 * 在屏幕中央显示一个Toast
	 * @param text
	 */
	public static void showToast(Context context, CharSequence text) {
		Toast toast = Toast.makeText(context, text, Toast.LENGTH_SHORT);
		toast.setGravity(Gravity.CENTER, 0, 0);
		toast.show();
	}

}

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".HelloBaiduMapActivity" >

    <com.baidu.mapapi.map.MapView  
	    android:id="@+id/bmapView"  
	    android:layout_width="fill_parent"  
	    android:layout_height="fill_parent"  
	    android:clickable="true" />

</RelativeLayout>

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:background="@drawable/popupmap"
    android:gravity="center_vertical" >
    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginBottom="2dip"
        android:src="@drawable/round" />
    <TextView
        android:id="@+id/tv_title"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:ellipsize="end"
        android:text="标题"
        android:textSize="20sp" />
    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@drawable/roads" />
</LinearLayout>

三、运行中遇到的问题

运行中需要用到key,要去百度地图开发平台申请，并且一个Key只能用于一个应用。