程序博客网 > 泰州淘宝网店装修步骤

百度地图的简单开发之实现地图全景，内景展示功能（四）

来源：互联网 发布：泰州淘宝网店装修步骤 编辑：程序博客网 时间：2024/06/05 09:01

今天,我就接着来浅谈一下关于百度地图的内景，外景的展示功能。今天具体要实现的功能就是输入该地点的名称然后就展示该地点的内景图片，有内景就展示内景，没有则显示该地点的街景，该功能是参考百度地图官方的API来实现。

     实现街景展示的地点的搜索，需要涉及到几个方面的知识：HttpClient网络请求封装，解析JSON数据，封装解析后JSON数据。其实展示内景或者外景很简单，只需要获取到内景的uid（POI的id），外景的经纬度即可，然后通过相应的API即可设置。关键点就是如何去获得我输入地点的uid或者经纬度呢？？这时候百度地图开放平台提供一个接口，就是输入一地点它就会返回该地点的uid和经纬度等信息的JSON数据，而我们只需要去解析这些JSON数据，就可以得到我们想要的uid和经纬度信息。大致的思路是这样的。

一、熟悉百度地图官方接口API数据的使用。

1、首先进入百度地图API官网，点击进入一个web服务API，然后选择PlaceAPI

通过以上介绍你应该就可以得到一个可以测试的URL，只要传入我们申请的APPKEY，根据传入不同的地点名称就会返回一个JSON数据。到底可不可以呢，其实我们可以测试一下，如果可以的话，我只要按要求拼接好URL，并把该URL粘贴到浏览器地址栏会返回一大串的JSON数据，如果返回了，那么我们成功拿到了数据，就可以进行下一步了。

http://api.map.baidu.com/place/v2/search?ak=3QIYhSeKPK770bpwzepo9GI1&output=json&query=北京大学&page_size=10&page_num=0&scope=1&region=全国

看来我们这样的拼接的URL还是存在着问题，它说少了一个参数，其实仔细思考一下，发现也很正常，因为我们的APPKEY是申请的类型Android手机类型，而这里的接口是提供web服务的，如果申请的APPKEY的类型是JavaScript类型的话，那么就无需mcode参数。而如果是android或者iOS则需要在URL后面再增添一个mcode参数，那么我们知道mcode是必需的，那么这mcode参数值是什么呢？？其实的它的值就是你的Eclipse中的SHA1 fingerprint值和你的项目的包名组合中间用“;"连接具体如下:

 

最终得到如下的URL：

http://api.map.baidu.com/place/v2/search?ak=nylibTfKmZw9mGe3juhT3U9x&output=json&query=北京大学&page_size=10&page_num=0&scope=1&region=全国&mcode=F5:3E:06:3E:FC:E8:ED:19:60:2E:99:63:D8:78:85:2E:EB:12:9D:BE;com.mikyou.maptest

 可以使用如下的URL粘贴浏览器测试一下，看是否可以返回JSON数据。最终发现可以返回JSON数据，那么到这里我们就知道了如何从百度官方拿到我们想要的数据。

并且从返回的JSON数据可以得到lat(经度)，lng(纬度)，streetId（街景id），uid（内景Id）等一系列的数据。那么接下来我们只需要利用的android的HttpClient中的get或post请求网络数据，得到返回的JSON数据，然后我们解析这些JSON数据得到经纬度，streetid，uid，然后把这些设置给百度全景展示的API即能实现全景和内景功能。

二、要实现全景功能需要在AndroidManifest.xml中配置一下BaseAppcation,用于对全景显示的初始化

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. package com.mikyou.tools;  
  2.   
  3. import android.app.Application;  
  4. import android.content.Context;  
  5. import android.widget.Toast;  
  6.   
  7. import com.baidu.lbsapi.BMapManager;  
  8. import com.baidu.lbsapi.MKGeneralListener;  
  9.   
  10. import com.baidu.mapapi.SDKInitializer;  
  11.   
  12. public class BaseApplication extends Application {  
  13.     private static Context mContext;  
  14.     public static float sScale;  
  15.     public static int sWidthDp;  
  16.     public static int sWidthPix;  
  17.     public BMapManager mBMapManager = null;  
  18.     private static BaseApplication mInstance;  
  19.     public static BaseApplication getInstance() {  
  20.         return mInstance;  
  21.     }  
  22.     @Override  
  23.     public void onCreate() {  
  24.         super.onCreate();  
  25.         SDKInitializer.initialize(this);  
  26.         initEngineManager(this);  
  27.         mContext = this;  
  28.         mInstance = this;  
  29.         sScale = getResources().getDisplayMetrics().density;  
  30.         sWidthPix = getResources().getDisplayMetrics().widthPixels;  
  31.         sWidthDp = (int) (sWidthPix / sScale);  
  32.     }  
  33.     public void initEngineManager(Context context) {  
  34.         if (mBMapManager == null) {  
  35.             mBMapManager = new BMapManager(context);  
  36.         }  
  37.         if (!mBMapManager.init(new MyGeneralListener())) {  
  38.             Toast.makeText(  
  39.                     BaseApplication.getInstance().getApplicationContext(),  
  40.                     "BMapManager!", Toast.LENGTH_LONG).show();  
  41.         }  
  42.     }  
  43.     public static class MyGeneralListener implements MKGeneralListener {  
  44.         @Override  
  45.         public void onGetPermissionState(int iError) {  
  46.           
  47.             if (iError != 0) {  
  48.             } else {  
  49.             }  
  50.         }  
  51.     }  
  52. }  
[html] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <application  
  2.       android:name="com.mikyou.tools.BaseApplication"<!-- 配置在此处 -->  
  3.        android:allowBackup="true"  
  4.        android:icon="@drawable/icon"  
  5.        android:label="@string/app_name"  
  6.        android:theme="@style/AppTheme" >  
  7.        <meta-data  
  8.            android:name="com.baidu.lbsapi.API_KEY"  
  9.            android:value="nylibTfKmZw9mGe3juhT3U9x" />  
  10.   
  11.        <activity  
  12.            android:name="com.mikyou.maptest.MainActivity"  
  13.            android:label="@string/app_name" >  
  14.            <intent-filter>  
  15.                <action android:name="android.intent.action.MAIN" />  
  16.   
  17.                <category android:name="android.intent.category.LAUNCHER" />  
  18.            </intent-filter>  
  19.        </activity>  
  20.   
  21.        <service  
  22.            android:name="com.baidu.location.f"  
  23.            android:enabled="true"  
  24.            android:process=":remote" >  
  25.            <intent-filter>  
  26.                <action android:name="com.baidu.location.service_v2.2" >  
  27.                </action>  
  28.            </intent-filter>  
  29.        </service>  
  30.   
  31.        <activity  
  32.            android:name="com.mikyou.maptest.OtherPnoramaActivity"  
  33.            android:label="@string/title_activity_other_pnorama" >  
  34.        </activity>  
  35.    </application>  


 

三、实现HttpClient中的网络数据请求，自己个人封装一个HttpUtil类，里面有个方法它能直接返回一个JSON对象。

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. package com.mikyou.tools;  
  2.   
  3. import java.io.IOException;  
  4. import java.util.List;  
  5.   
  6. import org.apache.http.HttpEntity;  
  7. import org.apache.http.HttpResponse;  
  8. import org.apache.http.NameValuePair;  
  9. import org.apache.http.ParseException;  
  10. import org.apache.http.client.ClientProtocolException;  
  11. import org.apache.http.client.HttpClient;  
  12. import org.apache.http.client.entity.UrlEncodedFormEntity;  
  13. import org.apache.http.client.methods.HttpGet;  
  14. import org.apache.http.client.methods.HttpPost;  
  15. import org.apache.http.impl.client.DefaultHttpClient;  
  16. import org.apache.http.protocol.HTTP;  
  17. import org.apache.http.util.EntityUtils;  
  18. import org.json.JSONException;  
  19. import org.json.JSONObject;  
  20.   
  21. /** 
  22.  * @author mikyou 
  23.  * 封装get和post方式请求 
  24.  * HttpClient 维护session 
  25.  * 一个HttpClient对象代表一个浏览器 
  26.  * 高度封装了客户端与服务端交互的，可以直接返回一个JSONObject对象 
  27.  * */  
  28. public class HttpUtils {  
  29.     private static  JSONObject jsonObjects;  
  30.     private static String entityString;  
  31.     private static HttpResponse res=null;  
  32.     private static String APPKEY="nylibTfKmZw9mGe3juhT3U9x";//APPKEY  
  33.     private static String outputForm="json";//返回网络数据的格式  
  34.     private static String Head="http://api.map.baidu.com/place/v2/search?ak=";//URL接口地址首部  
  35.     private static String IP=null;  
  36.     private static int pageSize=20;//一次返回数据总条数  
  37.     private static String mcode="F5:3E:06:3E:FC:E8:ED:19:60:2E:99:63:D8:78:85:2E:EB:12:9D:BE;com.mikyou.maptest";//mcode参数  
  38.     private static HttpClient clients=new DefaultHttpClient();  
  39.     @SuppressWarnings("unused")  
  40.     public static JSONObject send(String destination,List<NameValuePair> params) throws ClientProtocolException, IOException, JSONException{  
  41.   
  42.         if (params==null) {//表示发送get方式请求，否则就发送Post发送请求(因为get方式不需要params)  
  43.             IP=Head+APPKEY+"&output="+outputForm+"&query="+destination+"&page_size="+pageSize+"&page_num=0&scope=1&region=全国&mcode="+mcode;  
  44.             System.out.println("IP_Address:--------->"+IP);  
  45.             HttpGet get=new HttpGet(IP);  
  46.             res=clients.execute(get);  
  47.         }else{  
  48.             HttpPost post=new HttpPost(IP);  
  49.             post.setEntity(new UrlEncodedFormEntity(params,HTTP.UTF_8));  
  50.             res=clients.execute(post);  
  51.         }  
  52.         if (res.getStatusLine().getStatusCode()==200) {  
  53.             HttpEntity entity=res.getEntity();  
  54.             entityString=EntityUtils.toString(entity,HTTP.UTF_8);  
  55.             System.out.println("httpUtils--------------->"+entityString);  
  56.             jsonObjects=new JSONObject(entityString);  
  57.         }  
  58.         return jsonObjects;  
  59.     }  
  60.     public static String getEntityString() {  
  61.         return entityString;  
  62.     }  
  63.     public static void setEntityString(String entityString) {  
  64.         HttpUtils.entityString = entityString;  
  65.     }  
  66. }  

接着就是使用HttpUtil去进行Http请求，我们在进行网络请求数据，一般都是耗时的操作，所以需要去开启一个子线程来专门进行网络请求，从而可以避免阻塞主线程不至于真个应用直接崩溃。子线程得到JSON对象后，还得需要通过Handler对象去把该对象传递给主线程，然后再到主线程中去解析JSON数据，最后让这些数据更新我们的UI，因为子线程是无法更新UI的。为了数据的读取的方便性，先将解析后的数据每一条数据保存成一个SearchInfo对象，整个数据就可以保存在SearchInfoList集合中，需要的时候就可以随时去取。

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. /** 
  2.          * @author mikyou 
  3.          * 根据输入搜索的信息，从网络获得的JSON数据 
  4.          * 开启一个线程去获取网络数据 
  5.          * getSearchDataFromNetWork 
  6.          * */  
  7.         private void getSearchDataFromNetWork() {  
  8.             new Thread(new Runnable() {  
  9.                 @Override  
  10.                 public void run() {  
  11.                     try {  
  12.                         JSONObject jsonObject=HttpUtils.send(searchEdit.getText().toString(), null);  
  13.                         Message msg=new Message();  
  14.                         msg.obj=jsonObject;  
  15.                         msg.what=0x1234;  
  16.                         handler.sendMessage(msg);  
  17.                     } catch (ClientProtocolException e) {  
  18.                         e.printStackTrace();  
  19.                     } catch (IOException e) {  
  20.                         e.printStackTrace();  
  21.                     } catch (JSONException e) {  
  22.                         e.printStackTrace();  
  23.                     }  
  24.                 }  
  25.             }).start();               
  26.         }  
  27.     });  
  28. }  
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. //搜索网络请求API得到的JSON数据  
  2.     /** 
  3.      * @author zhongqihong 
  4.      * 利用子线程请求中得到的网络数据，利用Handler来更新 
  5.      * 主线程(即UI线程) 
  6.      * */  
  7.     private Handler handler=new Handler(){  
  8.         public void handleMessage(android.os.Message msg) {  
  9.             if (msg.what==0x1234) {  
  10.                 JSONObject object=(JSONObject) msg.obj;  
  11.                 //toast("json:----->"+object.toString());  
  12.                 //解析开始:然后把每一个地点信息封装到SearchInfo类中  
  13.                 try {  
  14.                     JSONArray array=object.getJSONArray("results");  
  15.                     for (int i = 0; i < array.length(); i++) {  
  16.                         JSONObject joObject=array.getJSONObject(i);  
  17.                         String name=joObject.getString("name");  
  18.                         JSONObject  object2=joObject.getJSONObject("location");  
  19.                         double lat=object2.getDouble("lat");  
  20.                         double lng=object2.getDouble("lng");  
  21.                         String address=joObject.getString("address");  
  22.                         String streetIds=joObject.getString("street_id");  
  23.                         String uids=joObject.getString("uid");  
  24.                         SearchInfo mInfo=new SearchInfo(name, lat, lng, address, streetIds, uids);  
  25.                         searchInfoLists.add(mInfo);  
  26.                     }  
  27.   
  28.                 } catch (JSONException e) {  
  29.                     // TODO Auto-generated catch block  
  30.                     e.printStackTrace();  
  31.                 }  
  32.   
  33.             }  
  34.             displayInDialog();  
  35.         }  

然后通过displayInDialog方法将解析后的数据，显示在一个列表对话框中。，并且给每个列表项设置点击事件，当点击其中一项，就会把该项的SearchInfo存入的信息读取出经纬度信息，然后通过经纬度信息就可以创建一个经纬度对象，最后把该对象设置给地图，然后该地图就可以定位到该点在地图上的位置，并用一个全景的图标标识，最后点击该图标就会开启一个新的Activity来显示该点的全景或者内容，所以需要将该项的SearchInfo通过Intent对象传递过去。

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1.     /** 
  2.      * @author mikyou 
  3.      * 显示搜索后信息的自定义列表项对话框，以及对话框点击事件的处理 
  4.      * */  
  5.     private void displayInDialog() {  
  6.         if (searchInfoLists!=null) {  
  7.             AlertDialog.Builder builder=new AlertDialog.Builder(MainActivity.this);  
  8.             builder.setIcon(R.drawable.calibration_arrow)  
  9.             .setTitle("请选择你查询到的地点")  
  10.             .setAdapter(new myDialogListAdapter(), new DialogInterface.OnClickListener() {  
  11.   
  12.                 @Override  
  13.                 public void onClick(DialogInterface dialog, int which) {  
  14.                     final SearchInfo mInfos=searchInfoLists.get(which);  
  15.                     uid=mInfos.getUid();  
  16.                     myBaiduMap.setOnMarkerClickListener(new OnMarkerClickListener() {  
  17.                         @Override  
  18.                         public boolean onMarkerClick(Marker PnoramaMark) {  
  19.                             Intent intent=new Intent(MainActivity.this, OtherPnoramaActivity.class);  
  20.                             intent.putExtra("info", mInfos);  
  21.                             startActivity(intent);  
  22.                             return true;  
  23.                         }  
  24.                     });  
  25.                     addPnoramaLayout(mInfos);//  
  26.                 }  
  27.             }).show();  
  28.         }else{  
  29.             toast("未查询到相关地点");  
  30.         }  
  31.     }  
  32. };  

接着通过addPnoramaLayout(mInfos);方法将全景的覆盖物的图标添加到相对应地图的位置

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * @author mikyou 
  3.  * 添加全景覆盖物，即全景的图标，迅速定位到该地点在地图上的位置 
  4.  * */  
  5. public void addPnoramaLayout(SearchInfo mInfos) {  
  6.     myBaiduMap.clear();   
  7.     LatLng latLng=new LatLng(mInfos.getLatitude(), mInfos.getLongtiude());  
  8.     Marker pnoramaMarker=null;  
  9.     OverlayOptions options;  
  10.     BitmapDescriptor mPnoramaIcon=BitmapDescriptorFactory.fromResource(R.drawable.icon_card_streetscape_blue);  
  11.     options=new MarkerOptions().position(latLng).icon(mPnoramaIcon).zIndex(6);  
  12.     pnoramaMarker=(Marker) myBaiduMap.addOverlay(options);  
  13.     MapStatusUpdate msu=MapStatusUpdateFactory.newLatLng(latLng);  
  14.     myBaiduMap.animateMapStatus(msu);  
  15. }  

最后通过全景覆盖物的点击事件就可以开起一个新Activity来显示内景和全景，通过Intent传递一个当前点击的Item项SearchInfo对象

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. myBaiduMap.setOnMarkerClickListener(new OnMarkerClickListener() {  
  2.                 @Override  
  3.                 public boolean onMarkerClick(Marker PnoramaMark) {  
  4.                     Intent intent=new Intent(MainActivity.this, OtherPnoramaActivity.class);  
  5.                     intent.putExtra("info", mInfos);  
  6.                     startActivity(intent);  
  7.                     return true;  
  8.                 }  
  9.             });  


四、那么接下来就是对设置街景、内景API操作了，因为通过上一步传来的SearchInfo对象中保存了我们实现内景的所需的数据信息。

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. /** 
  2.      * @author mikyou 
  3.      * 显示全景 
  4.      * */  
  5.     private void initPanoramaView() {  
  6.         SearchInfo info=(SearchInfo) getIntent().getSerializableExtra("info");//获取从MainActivity中传来的SearchInfo对象  
  7.         String uid=info.getUid();//得到设置内景必需的uid  
  8.         panoramaView=(PanoramaView) findViewById(R.id.panorama);  
  9.         //判断是否有内外景  
  10.         PanoramaRequest request=PanoramaRequest.getInstance(OtherPnoramaActivity.this);  
  11.         BaiduPoiPanoData poiPanoData=request.getPanoramaInfoByUid(uid);//将该uid设置给内景API  
  12.         panoramaView.setPanoramaImageLevel(ImageDefinition.ImageDefinitionMiddle);//表示展示的内景是中等分辨率，（ImageDefinitionHigh）高分辨率，（ImageDefinitionLow）低分辨率  
  13.         if (poiPanoData.hasInnerPano()) {//判断该POI是否有内景  
  14.             panoramaView.setPanoramaByUid(uid, PanoramaView.PANOTYPE_INTERIOR);  
  15.             panoramaView.setIndoorAlbumGone();//除去内景相册  
  16.             panoramaView.setIndoorAlbumVisible();//将内景相册显示  
  17.         }else if (poiPanoData.hasStreetPano()) {//判断该POI是否有外景,就只能通过经纬度来显示外景  
  18.             panoramaView.setPanorama(info.getLongtiude(), info.getLatitude());//没有内景就通过经纬度来展示街景  
  19.             //Toast.makeText(OtherPnoramaActivity.this, "有该地方的外景，wait", Toast.LENGTH_SHORT).show();  
  20.         }else{  
  21.             Toast.makeText(OtherPnoramaActivity.this, "sorry,网络不给力无法加载全景", Toast.LENGTH_SHORT).show();  
  22.         }  
  23.   
  24.     }  


五、全景功能明显也是高耗的功能，展示那么多高清大图需要很多网络流量那么则需要管理全景的生命周期，还是老方法将它的生命周期与该Activity的生命周期进行绑定即可。

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. @Override  
  2. protected void onPause() {  
  3.     panoramaView.onPause();  
  4.     super.onPause();  
  5. }  
  6. @Override  
  7. protected void onResume() {  
  8.     panoramaView.onResume();  
  9.     super.onResume();  
  10. }  
  11. @Override  
  12. protected void onDestroy() {  
  13.     panoramaView.destroy();  
  14.     super.onDestroy();  
  15. }  

 


里全景功能就介绍完毕，最后附上两个Activity的源码:

MainActivity.Java：

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. package com.mikyou.maptest;  
  2.   
  3. import java.io.IOException;  
  4. import java.util.ArrayList;  
  5. import java.util.List;  
  6.   
  7. import org.apache.http.client.ClientProtocolException;  
  8. import org.json.JSONArray;  
  9. import org.json.JSONException;  
  10. import org.json.JSONObject;  
  11.   
  12. import android.app.Activity;  
  13. import android.app.AlertDialog;  
  14. import android.content.DialogInterface;  
  15. import android.content.Intent;  
  16. import android.graphics.Color;  
  17. import android.graphics.Point;  
  18. import android.os.Bundle;  
  19. import android.os.Handler;  
  20. import android.os.Message;  
  21. import android.view.View;  
  22. import android.view.ViewGroup;  
  23. import android.view.View.OnClickListener;  
  24. import android.view.Window;  
  25. import android.widget.BaseAdapter;  
  26. import android.widget.EditText;  
  27. import android.widget.ImageView;  
  28. import android.widget.LinearLayout;  
  29. import android.widget.TextView;  
  30. import android.widget.Toast;  
  31. import android.widget.ZoomControls;  
  32.   
  33. import com.baidu.location.BDLocation;  
  34. import com.baidu.location.BDLocationListener;  
  35. import com.baidu.location.LocationClient;  
  36. import com.baidu.location.LocationClientOption;  
  37. import com.baidu.mapapi.SDKInitializer;  
  38. import com.baidu.mapapi.map.BaiduMap;  
  39. import com.baidu.mapapi.map.BaiduMap.OnMapClickListener;  
  40. import com.baidu.mapapi.map.BaiduMap.OnMarkerClickListener;  
  41. import com.baidu.mapapi.map.BitmapDescriptor;  
  42. import com.baidu.mapapi.map.BitmapDescriptorFactory;  
  43. import com.baidu.mapapi.map.InfoWindow;  
  44. import com.baidu.mapapi.map.MapPoi;  
  45. import com.baidu.mapapi.map.MapStatusUpdate;  
  46. import com.baidu.mapapi.map.MapStatusUpdateFactory;  
  47. import com.baidu.mapapi.map.MapView;  
  48. import com.baidu.mapapi.map.Marker;  
  49. import com.baidu.mapapi.map.MarkerOptions;  
  50. import com.baidu.mapapi.map.MyLocationConfiguration;  
  51. import com.baidu.mapapi.map.UiSettings;  
  52. import com.baidu.mapapi.map.MyLocationConfiguration.LocationMode;  
  53. import com.baidu.mapapi.map.MyLocationData;  
  54. import com.baidu.mapapi.map.OverlayOptions;  
  55. import com.baidu.mapapi.model.LatLng;  
  56. import com.mikyou.beans.MarkInfo;  
  57. import com.mikyou.beans.SearchInfo;  
  58. import com.mikyou.sensor.MyOrientationListener;  
  59. import com.mikyou.sensor.MyOrientationListener.onOrientationListener;  
  60. import com.mikyou.tools.HttpUtils;  
  61. public class MainActivity extends Activity implements OnClickListener,OnMapClickListener,OnMarkerClickListener{  
  62.     private MapView mapView=null;  
  63.     private BaiduMap myBaiduMap=null;  
  64.     //修改默认View相关  
  65.     private View defaultBaiduMapScaleButton,defaultBaiduMapLogo,defaultBaiduMapScaleUnit;  
  66.     //基本地图类型,实时交通，及覆盖物相关  
  67.     private ImageView mapRoad;  
  68.     private ImageView mapType;  
  69.     private String[] types={"普通地图","卫星地图","热力地图(已关闭)"};  
  70.     private float current;//放大或缩小的比例系数  
  71.     private ImageView expandMap;//放大地图控件  
  72.     private ImageView narrowMap;//缩小地图  
  73.     private ImageView addMarks;//添加覆盖物控件  
  74.     private BitmapDescriptor myMarks;  
  75.     private List<MarkInfo> markInfoList;  
  76.     private LinearLayout markLayout;  
  77.     //定位相关  
  78.     private LocationClient myLocationClient;//专门用于监听位置的客户端对象  
  79.     private MyLocationListener myListener;//定位监听器对象  
  80.     private double latitude,longtitude;//经纬度  
  81.     private BitmapDescriptor myBitmapLocation;//定位的自定义图标  
  82.     private boolean isFirstIn=true;//设置一个标记，查看是否是第一次  
  83.     private String locationTextString;//定义的位置的信息  
  84.     private TextView locationText;//显示定位信息的TextView控件  
  85.     private MyOrientationListener myOrientationListener;  
  86.     private float myCurrentX;  
  87.     private ImageView selectLocationMode;  
  88.     private ImageView myLocation;  
  89.     private String[] LocationModeString={"罗盘模式","普通模式","跟随模式","3D俯视模式(已关闭)"};  
  90.     //全景相关  
  91.     private EditText searchEdit;  
  92.     private ImageView okToSearch;  
  93.     private List<SearchInfo> searchInfoLists;  
  94.     private String uid;  
  95.     @Override  
  96.     protected void onCreate(Bundle savedInstanceState) {  
  97.         super.onCreate(savedInstanceState);  
  98.         requestWindowFeature(Window.FEATURE_NO_TITLE);  
  99.         SDKInitializer.initialize(getApplicationContext());  
  100.         setContentView(R.layout.activity_main);  
  101.         mapView=(MapView) findViewById(R.id.map_view_test);  
  102.         initMapView();  
  103.         changeDefaultBaiduMapView();  
  104.         initMapLocation();  
  105.         initSearchDestination();  
  106.     }  
  107.     /** 
  108.      * @author mikyou 
  109.      * 搜索相关 
  110.      * */  
  111.     private void initSearchDestination() {  
  112.         searchEdit=(EditText) findViewById(R.id.search_panorama);  
  113.         okToSearch=(ImageView) findViewById(R.id.ok_to_search);  
  114.         okToSearch.setOnClickListener(new OnClickListener() {  
  115.             @Override  
  116.             public void onClick(View v) {  
  117.                 searchInfoLists=new ArrayList<SearchInfo>();  
  118.                 getSearchDataFromNetWork();  
  119.             }  
  120.             /** 
  121.              * @author mikyou 
  122.              * 根据输入搜索的信息，从网络获得的JSON数据 
  123.              * 开启一个线程去获取网络数据 
  124.              * getSearchDataFromNetWork 
  125.              * */  
  126.             private void getSearchDataFromNetWork() {  
  127.                 new Thread(new Runnable() {  
  128.                     @Override  
  129.                     public void run() {  
  130.                         try {  
  131.                             JSONObject jsonObject=HttpUtils.send(searchEdit.getText().toString(), null);  
  132.                             Message msg=new Message();  
  133.                             msg.obj=jsonObject;  
  134.                             msg.what=0x1234;  
  135.                             handler.sendMessage(msg);  
  136.                         } catch (ClientProtocolException e) {  
  137.                             e.printStackTrace();  
  138.                         } catch (IOException e) {  
  139.                             e.printStackTrace();  
  140.                         } catch (JSONException e) {  
  141.                             e.printStackTrace();  
  142.                         }  
  143.                     }  
  144.                 }).start();               
  145.             }  
  146.         });  
  147.     }  
  148.     //搜索网络请求API得到的JSON数据  
  149.     /** 
  150.      * @author mikyou 
  151.      * 利用子线程请求中得到的网络数据，利用Handler来更新 
  152.      * 主线程(即UI线程) 
  153.      * */  
  154.     private Handler handler=new Handler(){  
  155.         public void handleMessage(android.os.Message msg) {  
  156.             if (msg.what==0x1234) {  
  157.                 JSONObject object=(JSONObject) msg.obj;  
  158.                 //toast("json:----->"+object.toString());  
  159.                 //解析开始:然后把每一个地点信息封装到SearchInfo类中  
  160.                 try {  
  161.                     JSONArray array=object.getJSONArray("results");  
  162.                     for (int i = 0; i < array.length(); i++) {  
  163.                         JSONObject joObject=array.getJSONObject(i);  
  164.                         String name=joObject.getString("name");  
  165.                         JSONObject  object2=joObject.getJSONObject("location");  
  166.                         double lat=object2.getDouble("lat");  
  167.                         double lng=object2.getDouble("lng");  
  168.                         String address=joObject.getString("address");  
  169.                         String streetIds=joObject.getString("street_id");  
  170.                         String uids=joObject.getString("uid");  
  171.                         SearchInfo mInfo=new SearchInfo(name, lat, lng, address, streetIds, uids);  
  172.                         searchInfoLists.add(mInfo);  
  173.                     }  
  174.   
  175.                 } catch (JSONException e) {  
  176.                     // TODO Auto-generated catch block  
  177.                     e.printStackTrace();  
  178.                 }  
  179.   
  180.             }  
  181.             displayInDialog();  
  182.         }  
  183.         /** 
  184.          * @author mikyou 
  185.          * 显示搜索后信息的自定义列表项对话框，以及对话框点击事件的处理 
  186.          * */  
  187.         private void displayInDialog() {  
  188.             if (searchInfoLists!=null) {  
  189.                 AlertDialog.Builder builder=new AlertDialog.Builder(MainActivity.this);  
  190.                 builder.setIcon(R.drawable.calibration_arrow)  
  191.                 .setTitle("请选择你查询到的地点")  
  192.                 .setAdapter(new myDialogListAdapter(), new DialogInterface.OnClickListener() {  
  193.   
  194.                     @Override  
  195.                     public void onClick(DialogInterface dialog, int which) {  
  196.                         final SearchInfo mInfos=searchInfoLists.get(which);  
  197.                         uid=mInfos.getUid();  
  198.                         myBaiduMap.setOnMarkerClickListener(new OnMarkerClickListener() {  
  199.                             @Override  
  200.                             public boolean onMarkerClick(Marker PnoramaMark) {  
  201.                                 Intent intent=new Intent(MainActivity.this, OtherPnoramaActivity.class);  
  202.                                 intent.putExtra("info", mInfos);  
  203.                                 startActivity(intent);  
  204.                                 return true;  
  205.                             }  
  206.                         });  
  207.                         addPnoramaLayout(mInfos);//  
  208.                     }  
  209.   
  210.   
  211.                 }).show();  
  212.             }else{  
  213.                 toast("未查询到相关地点");  
  214.             }  
  215.         }  
  216.     };  
  217.     /** 
  218.      * @author mikyou 
  219.      * 添加全景覆盖物，即全景的图标，迅速定位到该地点在地图上的位置 
  220.      * */  
  221.     public void addPnoramaLayout(SearchInfo mInfos) {  
  222.         myBaiduMap.clear();   
  223.         LatLng latLng=new LatLng(mInfos.getLatitude(), mInfos.getLongtiude());  
  224.         Marker pnoramaMarker=null;  
  225.         OverlayOptions options;  
  226.         BitmapDescriptor mPnoramaIcon=BitmapDescriptorFactory.fromResource(R.drawable.icon_card_streetscape_blue);  
  227.         options=new MarkerOptions().position(latLng).icon(mPnoramaIcon).zIndex(6);  
  228.         pnoramaMarker=(Marker) myBaiduMap.addOverlay(options);  
  229.         MapStatusUpdate msu=MapStatusUpdateFactory.newLatLng(latLng);  
  230.         myBaiduMap.animateMapStatus(msu);  
  231.     }  
  232.     /** 
  233.      * @author mikyou 
  234.      * 将我们搜索的信息来自网络的JSON数据解析后，封装在一个SearchInfo类中 
  235.      * 然后将这些数据展示在一个自定义的列表项的对话框中，以下就为定义列表项的适配器 
  236.      * ListAdapter 
  237.      * */  
  238.     class myDialogListAdapter extends BaseAdapter{  
  239.         @Override  
  240.         public int getCount() {  
  241.             return searchInfoLists.size();  
  242.         }  
  243.   
  244.         @Override  
  245.         public Object getItem(int position) {  
  246.             return getItem(position);  
  247.         }  
  248.   
  249.         @Override  
  250.         public long getItemId(int position) {  
  251.             return position;  
  252.         }  
  253.   
  254.         @Override  
  255.         public View getView(int position, View convertView, ViewGroup parent) {  
  256.             SearchInfo mSearchInfo=searchInfoLists.get(position);  
  257.             View view=View.inflate(MainActivity.this, R.layout.dialog_list_item, null);  
  258.             TextView desnameTv=(TextView) view.findViewById(R.id.desname);  
  259.             TextView addressTv=(TextView) view.findViewById(R.id.address);  
  260.             desnameTv.setText(mSearchInfo.getDesname());  
  261.             addressTv.setText(mSearchInfo.getAddress());  
  262.             return view;  
  263.         }  
  264.   
  265.     }  
  266.   
  267.     /** 
  268.      * @author Mikyou 
  269.      * 初始化定位功能 
  270.      * */  
  271.     private void initMapLocation() {  
  272.         myLocationClient=new LocationClient(this);//创建一个定位客户端对象  
  273.         myListener=new MyLocationListener();//创建一个定位事件监听对象  
  274.         myLocationClient.registerLocationListener(myListener);//并给该定位客户端对象注册监听事件  
  275.         //对LocaitonClient进行一些必要的设置  
  276.         LocationClientOption option=new LocationClientOption();  
  277.         option.setCoorType("bd09ll");//设置坐标的类型  
  278.         option.setIsNeedAddress(true);//返回当前的位置信息，如果不设置为true，默认就为false，就无法获得位置的信息  
  279.         option.setOpenGps(true);//打开GPS  
  280.         option.setScanSpan(1000);//表示1s中进行一次定位请求  
  281.         myLocationClient.setLocOption(option);  
  282.         useLocationOrientationListener();//调用方向传感器  
  283.     }  
  284.     /** 
  285.      * @author Mikyou 
  286.      * 定位结合方向传感器，从而可以实时监测到X轴坐标的变化，从而就可以检测到 
  287.      * 定位图标方向变化，只需要将这个动态变化的X轴的坐标更新myCurrentX值， 
  288.      * 最后在MyLocationData data.driection(myCurrentX); 
  289.      * */  
  290.     private void useLocationOrientationListener() {  
  291.         myOrientationListener=new MyOrientationListener(MainActivity.this);  
  292.         myOrientationListener.setMyOrientationListener(new onOrientationListener() {  
  293.             @Override  
  294.             public void onOrientationChanged(float x) {//监听方向的改变，方向改变时，需要得到地图上方向图标的位置  
  295.                 myCurrentX=x;  
  296.                 System.out.println("方向:x---->"+x);  
  297.             }  
  298.         });       
  299.     }  
  300.     /** 
  301.      * @author mikyou 
  302.      * 获取位置信息的客户端对象的监听器类MyLocationListener 
  303.      * */  
  304.     class MyLocationListener implements BDLocationListener{  
  305.   
  306.         @Override  
  307.         public void onReceiveLocation(BDLocation location) {  
  308.             //得到一个MyLocationData对象，需要将BDLocation对象转换成MyLocationData对象  
  309.             MyLocationData data=new MyLocationData.Builder()  
  310.             .accuracy(location.getRadius())//精度半径  
  311.             .direction(myCurrentX)//方向  
  312.             .latitude(location.getLatitude())//经度  
  313.             .longitude(location.getLongitude())//纬度  
  314.             .build();  
  315.             myBaiduMap.setMyLocationData(data);  
  316.             //配置自定义的定位图标,需要在紧接着setMyLocationData后面设置  
  317.             //调用自定义定位图标  
  318.             changeLocationIcon();  
  319.             latitude=location.getLatitude();//得到当前的经度  
  320.             longtitude=location.getLongitude();//得到当前的纬度  
  321.             //toast("经度："+latitude+"     纬度:"+longtitude);  
  322.             if (isFirstIn) {//表示用户第一次打开，就定位到用户当前位置，即此时只要将地图的中心点设置为用户此时的位置即可  
  323.                 getMyLatestLocation(latitude,longtitude);//获得最新定位的位置,并且地图的中心点设置为我的位置  
  324.                 isFirstIn=false;//表示第一次才会去定位到中心点  
  325.                 locationTextString=""+location.getAddrStr();//这里得到地址必须需要在设置LocationOption的时候需要设置isNeedAddress为true;  
  326.                 toast(locationTextString);  
  327.                 locationText.setText(locationTextString);  
  328.             }  
  329.         }  
  330.   
  331.   
  332.   
  333.   
  334.     }  
  335.     /** 
  336.      * @author zhongqihong 
  337.      * 获得最新定位的位置,并且地图的中心点设置为我的位置 
  338.      * */  
  339.     private void getMyLatestLocation(double lat,double lng) {  
  340.         LatLng latLng=new LatLng(lat, lng);//创建一个经纬度对象，需要传入当前的经度和纬度两个整型值参数  
  341.         MapStatusUpdate msu=MapStatusUpdateFactory.newLatLng(latLng);//创建一个地图最新更新的状态对象，需要传入一个最新经纬度对象  
  342.         myBaiduMap.animateMapStatus(msu);//表示使用动画的效果传入，通过传入一个地图更新状态对象，然后利用百度地图对象来展现和还原那个地图更新状态，即此时的地图显示就为你现在的位置  
  343.     }  
  344.   
  345.     /** 
  346.      * @author zhongqihong 
  347.      * 自定义定位图标 
  348.      * */  
  349.     private void changeLocationIcon() {  
  350.         myBitmapLocation=BitmapDescriptorFactory  
  351.                 .fromResource(R.drawable.ic_launcher);//引入自己的图标  
  352.         if (isFirstIn) {//表示第一次定位显示普通模式  
  353.             MyLocationConfiguration config=new   
  354.                     MyLocationConfiguration(LocationMode.NORMAL, true, myBitmapLocation);  
  355.             myBaiduMap.setMyLocationConfigeration(config);  
  356.         }             
  357.     }  
  358.     /** 
  359.      * @author zhongqihong 
  360.      * 初始化地图的View 
  361.      * */  
  362.     private void initMapView() {  
  363.         registerAllIds();  
  364.         registerAllEvents();  
  365.     }  
  366.     private void registerAllIds() {  
  367.         mapRoad=(ImageView) findViewById(R.id.road_condition);  
  368.         mapType=(ImageView) findViewById(R.id.map_type);  
  369.         expandMap=(ImageView) findViewById(R.id.add_scale);  
  370.         narrowMap=(ImageView) findViewById(R.id.low_scale);  
  371.         addMarks=(ImageView) findViewById(R.id.map_marker);  
  372.         markLayout=(LinearLayout) findViewById(R.id.mark_layout);  
  373.         locationText=(TextView) findViewById(R.id.mylocation_text);  
  374.         selectLocationMode=(ImageView) findViewById(R.id.map_location);  
  375.         myLocation=(ImageView) findViewById(R.id.my_location);  
  376.   
  377.     }  
  378.     private void registerAllEvents() {  
  379.         mapRoad.setOnClickListener(this);  
  380.         mapType.setOnClickListener(this);  
  381.         expandMap.setOnClickListener(this);  
  382.         narrowMap.setOnClickListener(this);  
  383.         addMarks.setOnClickListener(this);  
  384.         selectLocationMode.setOnClickListener(this);  
  385.         myLocation.setOnClickListener(this);  
  386.     }  
  387.     /** 
  388.      * @author mikyou 
  389.      * 除去百度地图上的默认控件 
  390.      * */  
  391.     private void changeDefaultBaiduMapView() {  
  392.         changeInitialzeScaleView();//改变默认百度地图初始加载的地图比例  
  393.         //设置隐藏缩放和扩大的百度地图的默认的比例按钮  
  394.         for (int i = 0; i < mapView.getChildCount(); i++) {//遍历百度地图中的所有子View,找到这个扩大和缩放的按钮控件View，然后设置隐藏View即可  
  395.             View child=mapView.getChildAt(i);  
  396.             if (child instanceof ZoomControls) {  
  397.                 defaultBaiduMapScaleButton=child;//该defaultBaiduMapScaleButton子View是指百度地图默认产生的放大和缩小的按钮，得到这个View  
  398.                 break;  
  399.             }  
  400.         }  
  401.         defaultBaiduMapScaleButton.setVisibility(View.GONE);//然后将该View的Visiblity设为不存在和不可见，即隐藏  
  402.         defaultBaiduMapLogo =mapView.getChildAt(1);//该View是指百度地图中默认的百度地图的Logo,得到这个View  
  403.         defaultBaiduMapLogo.setPadding(300, -10, 100, 100);//设置该默认Logo View的位置，因为这个该View的位置会影响下面的刻度尺单位View显示的位置  
  404.         mapView.removeViewAt(1);//最后移除默认百度地图的logo View  
  405.         defaultBaiduMapScaleUnit=mapView.getChildAt(2);//得到百度地图的默认单位刻度的View  
  406.         defaultBaiduMapScaleUnit.setPadding(100, 0, 115,200);//最后设置调整百度地图的默认单位刻度View的位置       
  407.     }  
  408.     /** 
  409.      * @author mikyou 
  410.      * 改变默认初始化的地图的比例 
  411.      * */  
  412.     private void changeInitialzeScaleView() {  
  413.         myBaiduMap=mapView.getMap();//改变百度地图的放大比例,让首次加载地图就开始扩大到500米的距离,获得百度地图对象  
  414.         MapStatusUpdate factory=MapStatusUpdateFactory.zoomTo(15.0f);  
  415.         myBaiduMap.animateMapStatus(factory);         
  416.     }  
  417.     /** 
  418.      * @author mikyou 
  419.      * 管理地图的生命周期 
  420.      * */  
  421.     protected void onDestroy() {  
  422.         super.onDestroy();  
  423.         //在Activity执行onDestory时执行mapView(地图)生命周期管理  
  424.         mapView.onDestroy();  
  425.     }  
  426.     @Override  
  427.     protected void onStart() {//当Activity调用onStart方法，开启定位以及开启方向传感器，即将定位的服务、方向传感器和Activity生命周期绑定在一起  
  428.         myBaiduMap.setMyLocationEnabled(true);//开启允许定位  
  429.         if (!myLocationClient.isStarted()) {  
  430.             myLocationClient.start();//开启定位  
  431.         }  
  432.         //开启方向传感器  
  433.         myOrientationListener.start();  
  434.         super.onStart();  
  435.     }  
  436.     @Override  
  437.     protected void onStop() {//当Activity调用onStop方法，关闭定位以及关闭方向传感器  
  438.         myBaiduMap.setMyLocationEnabled(false);  
  439.         myLocationClient.stop();//关闭定位  
  440.         myOrientationListener.stop();//关闭方向传感器  
  441.         super.onStop();  
  442.     }  
  443.     @Override  
  444.     protected void onResume() {  
  445.         // TODO Auto-generated method stub  
  446.         super.onResume();  
  447.         //在Activity执行onResume是执行MapView(地图)生命周期管理  
  448.         mapView.onResume();  
  449.     }  
  450.     @Override  
  451.     protected void onPause() {  
  452.         // TODO Auto-generated method stub  
  453.         super.onPause();  
  454.         mapView.onPause();  
  455.     }  
  456.     //点击事件相关  
  457.     @Override  
  458.     public void onClick(View v) {  
  459.         switch (v.getId()) {  
  460.         case R.id.road_condition://是否打开实时交通  
  461.             switchRoadCondition();  
  462.             break;  
  463.         case R.id.map_type://选择地图的类型  
  464.             selectMapType();  
  465.             break;  
  466.         case R.id.add_scale://放大地图比例  
  467.             expandMapScale();  
  468.             break;  
  469.         case R.id.low_scale://缩小地图比例  
  470.             narrowMapScale();  
  471.             break;  
  472.         case R.id.map_marker://添加覆盖物  
  473.             addMapMarks();  
  474.             break;  
  475.         case R.id.my_location://定位功能，需要用到LocationClient进行定位  
  476.             //BDLocationListener  
  477.             getMyLatestLocation(latitude,longtitude);  
  478.             break;  
  479.         case R.id.map_location://选择定位模式  
  480.             selectLocation();  
  481.             break;  
  482.         default:  
  483.             break;  
  484.         }  
  485.     }  
  486.     /** 
  487.      * @author mikyou 
  488.      * 选择定位的模式 
  489.      * */  
  490.     private void selectLocation() {  
  491.         AlertDialog.Builder builder2=new AlertDialog.Builder(this);  
  492.         builder2.setIcon(R.drawable.track_collect_running)  
  493.         .setTitle("请选择定位的模式")  
  494.         .setItems(LocationModeString, new DialogInterface.OnClickListener() {  
  495.   
  496.             @Override  
  497.             public void onClick(DialogInterface dialog, int which) {  
  498.                 String mode=LocationModeString[which];  
  499.                 if (mode.equals("罗盘模式")) {  
  500.                     MyLocationConfiguration config=new   
  501.                             MyLocationConfiguration(LocationMode.COMPASS, true, myBitmapLocation);  
  502.                     myBaiduMap.setMyLocationConfigeration(config);  
  503.                 }else if (mode.equals("跟随模式")) {  
  504.                     MyLocationConfiguration config=new   
  505.                             MyLocationConfiguration(LocationMode.FOLLOWING, true, myBitmapLocation);  
  506.                     myBaiduMap.setMyLocationConfigeration(config);  
  507.                 }else if (mode.equals("普通模式")) {  
  508.                     MyLocationConfiguration config=new   
  509.                             MyLocationConfiguration(LocationMode.NORMAL, true, myBitmapLocation);  
  510.                     myBaiduMap.setMyLocationConfigeration(config);  
  511.                 }else if (mode.equals("3D俯视模式(已关闭)")||mode.equals("3D俯视模式(已打开)")) {  
  512.                     if (mode.equals("3D俯视模式(已打开)")) {  
  513.                         UiSettings   mUiSettings = myBaiduMap.getUiSettings();  
  514.                         mUiSettings.setCompassEnabled(true);  
  515.                         LocationModeString[which]="3D俯视模式(已关闭)";  
  516.                         toast("3D模式已关闭");  
  517.                     }else{  
  518.                         MyLocationConfiguration config=new   
  519.                                 MyLocationConfiguration(LocationMode.COMPASS, true, myBitmapLocation);  
  520.                         myBaiduMap.setMyLocationConfigeration(config);  
  521.                         MyLocationConfiguration config2=new   
  522.                                 MyLocationConfiguration(LocationMode.NORMAL, true, myBitmapLocation);  
  523.                         myBaiduMap.setMyLocationConfigeration(config2);  
  524.                         LocationModeString[which]="3D俯视模式(已打开)";  
  525.                         toast("3D模式已打开");  
  526.                     }  
  527.                 }  
  528.             }  
  529.         }).show();        
  530.     }  
  531.     /** 
  532.      * @author Mikyou 
  533.      * 添加覆盖物 
  534.      * */  
  535.     private void addMapMarks() {  
  536.         initMarksData();  
  537.         myBaiduMap.clear();//先清除一下图层  
  538.         LatLng latLng=null;  
  539.         Marker marker=null;  
  540.         OverlayOptions options;  
  541.         myMarks=BitmapDescriptorFactory.fromResource(R.drawable.mark);//引入自定义的覆盖物图标，将其转化成一个BitmapDescriptor对象  
  542.         //遍历MarkInfo的List一个MarkInfo就是一个Mark  
  543.         for (int i = 0; i < markInfoList.size(); i++) {  
  544.             //经纬度对象  
  545.             latLng=new LatLng(markInfoList.get(i).getLatitude(), markInfoList.get(i).getLongitude());//需要创建一个经纬对象，通过该对象就可以定位到处于地图上的某个具体点  
  546.             //图标  
  547.             options=new MarkerOptions().position(latLng).icon(myMarks).zIndex(6);  
  548.             marker=(Marker) myBaiduMap.addOverlay(options);//将覆盖物添加到地图上  
  549.             Bundle bundle=new Bundle();//创建一个Bundle对象将每个mark具体信息传过去，当点击该覆盖物图标的时候就会显示该覆盖物的详细信息  
  550.             bundle.putSerializable("mark", markInfoList.get(i));  
  551.             marker.setExtraInfo(bundle);  
  552.         }  
  553.         MapStatusUpdate msu=MapStatusUpdateFactory.newLatLng(latLng);//通过这个经纬度对象，地图就可以定位到该点  
  554.         myBaiduMap.animateMapStatus(msu);  
  555.     }  
  556.     /** 
  557.      * @author mikyou 
  558.      * 初始化覆盖物信息数据 
  559.      * */  
  560.     private void initMarksData() {  
  561.         markInfoList=new ArrayList<MarkInfo>();  
  562.         markInfoList.add(new MarkInfo(32.079254, 118.787623, R.drawable.pic1, "英伦贵族小旅馆", "距离209米", 1888));  
  563.         markInfoList.add(new MarkInfo(32.064355, 118.787624, R.drawable.pic2, "沙井国际高级会所", "距离459米", 388));  
  564.         markInfoList.add(new MarkInfo(28.7487420000, 115.8748860000, R.drawable.pic4, "华东交通大学南区", "距离5米", 888));  
  565.         markInfoList.add(new MarkInfo(28.7534890000, 115.8767960000, R.drawable.pic3, "华东交通大学北区", "距离10米", 188));  
  566.         myBaiduMap.setOnMarkerClickListener(this);  
  567.         myBaiduMap.setOnMapClickListener(this);     
  568.     }  
  569.     /** 
  570.      * @author mikyou 
  571.      * 放大地图的比例 
  572.      * */  
  573.     private void narrowMapScale() {  
  574.         current-=0.5f;  
  575.         MapStatusUpdate msu=MapStatusUpdateFactory.zoomTo(15.0f+current);  
  576.         myBaiduMap.animateMapStatus(msu);  
  577.     }  
  578.     /** 
  579.      *@author mikyou 
  580.      *缩小地图的比例  
  581.      * */  
  582.     private void expandMapScale() {  
  583.         current+=0.5f;  
  584.         MapStatusUpdate msu2=MapStatusUpdateFactory.zoomTo(15.0f+current);  
  585.         myBaiduMap.animateMapStatus(msu2);  
  586.     }  
  587.     /** 
  588.      * @author mikyou 
  589.      * 选择地图的类型 
  590.      * */  
  591.     private void selectMapType() {  
  592.         AlertDialog.Builder builder=new AlertDialog.Builder(MainActivity.this);  
  593.         builder.setIcon(R.drawable.icon)  
  594.         .setTitle("请选择地图的类型")  
  595.         .setItems(types, new DialogInterface.OnClickListener() {  
  596.             @Override  
  597.             public void onClick(DialogInterface dialog, int which) {  
  598.                 String select=types[which];  
  599.                 if (select.equals("普通地图")) {  
  600.                     myBaiduMap.setMapType(BaiduMap.MAP_TYPE_NORMAL);  
  601.                 }else if (select.equals("卫星地图")) {  
  602.                     myBaiduMap.setMapType(BaiduMap.MAP_TYPE_SATELLITE);  
  603.                 }else if (select.equals("热力地图(已关闭)")||select.equals("热力地图(已打开)")) {  
  604.                     if(myBaiduMap.isBaiduHeatMapEnabled()) {  
  605.                         myBaiduMap.setBaiduHeatMapEnabled(false);  
  606.                         Toast.makeText(MainActivity.this, "热力地图已关闭", 0).show();  
  607.                         types[which]="热力地图(已关闭)";  
  608.                     }else {  
  609.                         myBaiduMap.setBaiduHeatMapEnabled(true);  
  610.                         Toast.makeText(MainActivity.this, "热力地图已打开", 0).show();  
  611.                         types[which]="热力地图(已打开)";  
  612.                     }  
  613.                 }  
  614.             }  
  615.         }).show();  
  616.     }  
  617.     /** 
  618.      * @author mikyou 
  619.      * 是否打开实时交通 
  620.      * */  
  621.     private void switchRoadCondition() {  
  622.         if (myBaiduMap.isTrafficEnabled()) {//如果是开着的状态，当点击后，就会出关闭状态  
  623.             myBaiduMap.setTrafficEnabled(false);  
  624.             mapRoad.setImageResource(R.drawable.main_icon_roadcondition_off);  
  625.         }else{//如果是的关闭的状态，当点击后，就会处于开启的状态  
  626.             myBaiduMap.setTrafficEnabled(true);  
  627.             mapRoad.setImageResource(R.drawable.main_icon_roadcondition_on);  
  628.         }  
  629.     }  
  630.     /** 
  631.      * @author mikyou 
  632.      * 覆盖物的点击事件 
  633.      * */  
  634.     @Override  
  635.     public boolean onMarkerClick(Marker marker) {  
  636.         Bundle bundle=  marker.getExtraInfo();  
  637.         MarkInfo MyMarker=(MarkInfo) bundle.getSerializable("mark");  
  638.         ImageView iv=(ImageView) markLayout.findViewById(R.id.mark_image);  
  639.         TextView distanceTv=(TextView) markLayout.findViewById(R.id.distance);  
  640.         TextView nameTv=(TextView) markLayout.findViewById(R.id.name);  
  641.         TextView zanNumsTv=(TextView) markLayout.findViewById(R.id.zan_nums);  
  642.         iv.setImageResource(MyMarker.getImageId());  
  643.         distanceTv.setText(MyMarker.getDistance()+"");  
  644.         nameTv.setText(MyMarker.getName());  
  645.         zanNumsTv.setText(MyMarker.getZanNum()+"");  
  646.         //初始化一个InfoWindow  
  647.         initInfoWindow(MyMarker,marker);  
  648.         markLayout.setVisibility(View.VISIBLE);  
  649.         return true;  
  650.     }  
  651.     /** 
  652.      *@author mikyou 
  653.      *初始化出一个InfoWindow 
  654.      *  
  655.      * */  
  656.     private void initInfoWindow(MarkInfo MyMarker,Marker marker) {  
  657.         // TODO Auto-generated method stub  
  658.         InfoWindow infoWindow;  
  659.         //InfoWindow中显示的View内容样式，显示一个TextView  
  660.         TextView infoWindowTv=new TextView(MainActivity.this);  
  661.         infoWindowTv.setBackgroundResource(R.drawable.location_tips);  
  662.         infoWindowTv.setPadding(30, 20, 30, 50);  
  663.         infoWindowTv.setText(MyMarker.getName());  
  664.         infoWindowTv.setTextColor(Color.parseColor("#FFFFFF"));  
  665.   
  666.         final LatLng latLng=marker.getPosition();  
  667.         Point p=myBaiduMap.getProjection().toScreenLocation(latLng);//将地图上的经纬度转换成屏幕中实际的点  
  668.         p.y-=47;//设置屏幕中点的Y轴坐标的偏移量  
  669.         LatLng ll=myBaiduMap.getProjection().fromScreenLocation(p);//把修改后的屏幕的点有转换成地图上的经纬度对象  
  670.         /** 
  671.          * @author mikyou 
  672.          * 实例化一个InfoWindow的对象 
  673.          * public InfoWindow(View view,LatLng position, int yOffset)通过传入的 view 构造一个 InfoWindow, 此时只是利用该view生成一个Bitmap绘制在地图中，监听事件由开发者实现。 
  674.          *  参数: 
  675.          * view - InfoWindow 展示的 view 
  676.          * position - InfoWindow 显示的地理位置 
  677.          * yOffset - InfoWindow Y 轴偏移量 
  678.          * */  
  679.         infoWindow=new InfoWindow(infoWindowTv, ll, 10);  
  680.         myBaiduMap.showInfoWindow(infoWindow);//显示InfoWindow  
  681.     }  
  682.     /** 
  683.      * @author mikyou 
  684.      * 给整个地图添加的点击事件 
  685.      * */  
  686.     @Override  
  687.     public void onMapClick(LatLng arg0) {//表示点击地图其他的地方使得覆盖物的详情介绍的布局隐藏，但是点击已显示的覆盖物详情布局上，则不会消失，因为在详情布局上添加了Clickable=true  
  688.         //由于事件的传播机制，因为点击事件首先会在覆盖物布局的父布局(map)中,由于map是可以点击的，map则会把点击事件给消费掉，如果加上Clickable=true表示点击事件由详情布局自己处理，不由map来消费  
  689.         markLayout.setVisibility(View.GONE);  
  690.         myBaiduMap.hideInfoWindow();//隐藏InfoWindow  
  691.     }  
  692.     @Override  
  693.     public boolean onMapPoiClick(MapPoi arg0) {  
  694.         return false;  
  695.     }  
  696.     public void toast(String str){  
  697.         Toast.makeText(MainActivity.this, str, 0).show();  
  698.     }  
  699. }  

OtherPnoramaActivity.java：

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. package com.mikyou.maptest;  
  2.   
  3. import com.baidu.lbsapi.BMapManager;  
  4. import com.baidu.lbsapi.model.BaiduPoiPanoData;  
  5. import com.baidu.lbsapi.panoramaview.PanoramaRequest;  
  6. import com.baidu.lbsapi.panoramaview.PanoramaView;  
  7. import com.baidu.lbsapi.panoramaview.PanoramaView.ImageDefinition;  
  8. import com.mikyou.beans.SearchInfo;  
  9. import com.mikyou.tools.SystemStatusManager;  
  10.   
  11. import android.os.Build;  
  12. import android.os.Bundle;  
  13. import android.app.Activity;  
  14. import android.view.Menu;  
  15. import android.view.Window;  
  16. import android.view.WindowManager;  
  17. import android.widget.Toast;  
  18.   
  19. public class OtherPnoramaActivity extends Activity {  
  20.     private double latitude,longtiude;  
  21.     private PanoramaView panoramaView;  
  22.     @Override  
  23.     protected void onCreate(Bundle savedInstanceState) {  
  24.         super.onCreate(savedInstanceState);  
  25.         requestWindowFeature(Window.FEATURE_NO_TITLE);  
  26.         setTranslucentStatus();  
  27.         setContentView(R.layout.activity_other_pnorama);  
  28.         initPanoramaView();  
  29.   
  30.     }  
  31.   
  32.   
  33.     @Override  
  34.     protected void onPause() {  
  35.         panoramaView.onPause();  
  36.         super.onPause();  
  37.     }  
  38.     @Override  
  39.     protected void onResume() {  
  40.         panoramaView.onResume();  
  41.         super.onResume();  
  42.     }  
  43.     @Override  
  44.     protected void onDestroy() {  
  45.         panoramaView.destroy();  
  46.         super.onDestroy();  
  47.     }  
  48.     /** 
  49.      * @author mikyou 
  50.      * 显示全景 
  51.      * */  
  52.     private void initPanoramaView() {  
  53.         SearchInfo info=(SearchInfo) getIntent().getSerializableExtra("info");//获取从MainActivity中传来的SearchInfo对象  
  54.         String uid=info.getUid();//得到设置内景必需的uid  
  55.         panoramaView=(PanoramaView) findViewById(R.id.panorama2);  
  56.         //判断是否有内外景  
  57.         PanoramaRequest request=PanoramaRequest.getInstance(OtherPnoramaActivity.this);  
  58.         BaiduPoiPanoData poiPanoData=request.getPanoramaInfoByUid(uid);//将该uid设置给内景API  
  59.         panoramaView.setPanoramaImageLevel(ImageDefinition.ImageDefinitionMiddle);//表示展示的内景是中等分辨率，（ImageDefinitionHigh）高分辨率，（ImageDefinitionLow）低分辨率  
  60.         if (poiPanoData.hasInnerPano()) {//判断该POI是否有内景  
  61.             panoramaView.setPanoramaByUid(uid, PanoramaView.PANOTYPE_INTERIOR);  
  62.             panoramaView.setIndoorAlbumGone();//除去内景相册  
  63.             panoramaView.setIndoorAlbumVisible();//将内景相册显示  
  64.         }else if (poiPanoData.hasStreetPano()) {//判断该POI是否有外景,就只能通过经纬度来显示外景  
  65.             panoramaView.setPanorama(info.getLongtiude(), info.getLatitude());//没有内景就通过经纬度来展示街景  
  66.             //Toast.makeText(OtherPnoramaActivity.this, "有该地方的外景，wait", Toast.LENGTH_SHORT).show();  
  67.         }else{  
  68.             Toast.makeText(OtherPnoramaActivity.this, "sorry,网络不给力无法加载全景", Toast.LENGTH_SHORT).show();  
  69.         }  
  70.     }  
  71.     private void setTranslucentStatus() {  
  72.         if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.KITKAT){  
  73.             Window win=getWindow();  
  74.             WindowManager.LayoutParams winParams=win.getAttributes();  
  75.             final int bits=WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS;  
  76.             winParams.flags |=bits;  
  77.             win.setAttributes(winParams);  
  78.         }  
  79.         SystemStatusManager tintManager = new SystemStatusManager(this);  
  80.         tintManager.setStatusBarTintEnabled(true);  
  81.         tintManager.setStatusBarTintResource(0);  
  82.         tintManager.setNavigationBarTintEnabled(true);  
  83.   
  84.     }  
  85. }  


运行效果:


 

 Demo下载链接

0 0
泰州淘宝网店装修步骤 泰州淘宝网店装修步骤
原创粉丝点击
热门IT博客
优化神马pc关键词排名优化神马pc关键词排名
warframe知乎warframe知乎
阿尔法软件怎么样
说明书排版软件
mysql教程pdf 百度网盘
r语言 知乎
怎样网络推广
天谕玉虚萝莉捏脸数据
网络转换器怎么用
linux内核社区
淘宝助理5.0下载
淘宝机票
小偷程序源码
中兴软件测试面试题
少儿编程培训班
批发商也开淘宝不
javascript全选反选
义乌淘宝摄影基地
辐射3胜利狙击枪数据
有意思的网站 知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 动脉导管未闭自愈条件 乳腺导管乳头状瘤 导管什么意思 乳腺导管堵塞怎么办 什么是乳腺导管扩张 乳腺导管局限性扩张 乳腺导管扩张怎么办 乳腺导管扩张综合征 中心静脉导管的护理 中心静脉导管的维护 导管扩张是怎么回事 什么叫乳腺导管扩张 乳腺导管扩张怎么引起的 乳腺导管扩张是 乳腺导管堵塞怎么疏通 乳腺导管扩张症状 乳腺导管病变 乳腺导管上皮增生 乳腺导管增宽 乳腺导管内瘤 乳腺导管扩张症的病因 乳腺导管增厚 空气导管防辐射耳机 双乳局限性导管扩张 乳腺导管增生 双乳导管扩张严重吗 乳腺导管扩张是乳腺增生吗 乳腺导管上皮细胞增生 乳腺导管扩张是什么回事 颌下腺导管结石 筛管和导管的区别 导管和筛管的区别 乳腺导管扩张吃什么药 导管瘤严重吗 一次性气管导管 静脉导管是什么 双腔支气管导管 中心静脉导管生产厂家 可挠金属导管 导管式卫生棉条怎么用 中心静脉导管包价格

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里