百度地图LBS云平台读写数据操作类

最近写了个叫《行踪记录仪》的手机软件，用了百度云来记录每个用户的最近位置，以便各用户能在地图上找到附近的人，为此写了个类来读写数据，大致如下：

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import org.apache.http.HttpHost;
 import org.apache.http.HttpResponse;
 import org.apache.http.HttpStatus;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.entity.UrlEncodedFormEntity;
 import org.apache.http.client.methods.HttpGet;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.client.params.ClientPNames;
 import org.apache.http.client.params.CookiePolicy;
 import org.apache.http.conn.params.ConnRoutePNames;
 import org.apache.http.impl.client.DefaultHttpClient;
 import org.apache.http.message.BasicNameValuePair;
 import org.apache.http.params.CoreConnectionPNames;
 import org.apache.http.params.HttpProtocolParams;
 import org.apache.http.util.EntityUtils;
 import org.json.JSONObject;

 import android.content.SharedPreferences;
 import android.os.Handler;
 import android.os.Message;
 import android.util.Log;

 import com.baidu.location.BDLocation;
 import com.baidu.platform.comapi.basestruct.GeoPoint;

 /**
  * 百度云检索类
  *
  * @author Robert Tsing
  */
 public class LBSCloud {

     private static String mTAG = "NetWorkManager";

     // 百度云检索API URI
     private static final String SEARCH_URI_NEARBY = "http://api.map.baidu.com/geosearch/v2/nearby?";
     private static final String SEARCH_URI_LOCAL = "http://api.map.baidu.com/geosearch/v2/local?";
     private static final String SEARCH_URI_BOUND = "http://api.map.baidu.com/geosearch/v2/bound?";
     private static final String SEARCH_URI_DETAIL = "http://api.map.baidu.com/geosearch/v2/detail?";
     private static final String SEARCH_URI_POI_LIST = "http://api.map.baidu.com/geodata/v2/poi/list?";

     private static final String POST_URI_CREATE = "http://api.map.baidu.com/geodata/v2/poi/create";
     private static final String POST_URI_UPDATE = "http://api.map.baidu.com/geodata/v2/poi/update";
     private static final String POST_URI_DELETE = "http://api.map.baidu.com/geodata/v2/poi/delete";

     public static final int SEARCH_TYPE_NEARBY = 1;
     public static final int SEARCH_TYPE_LOCAL = 2;
     public static final int SEARCH_TYPE_BOUND = 3;
     public static final int SEARCH_TYPE_DETAIL = 4;
     public static final int SEARCH_TYPE_POI_LIST = 5;

     public static final int POST_TYPE_CREATE = 6;
     public static final int POST_TYPE_UPDATE = 7;
     public static final int POST_TYPE_DELETE = 8;

     public static final int RESULT_GET = 0;
     public static final int RESULT_POST = 1;

     private static int currSearchType = 0;

     // 云检索公钥
     // private static String ak = "A321c32037052461d6958b34a3e?????";
     private static String ak = "E7d8211ca35fc64e838ee15b7d5?????";
     private static String geotable_id = "?????";
     private static String coord_type = "3";

     private static String CMWAP_HOST = "10.0.0.172";
     private static String CTWAP_HOST = "10.0.0.200";

     private static int TIME_OUT = 12000;
     private static int retry = 3;
     private static boolean Getting = false;

     /**
      * 云检索访问
      *
      * @param filterParams
      *            访问参数，key为filter时特殊处理。
      * @param handler
      *            数据回调Handler
      * @param networkType
      *            手机联网类型
      * @return
      */

      //读取的
     public static boolean request(final int searchType,
             final HashMap<String, String> filterParams, final Handler handler) {
         if (Getting || filterParams == null)
             return false;
         Getting = true;

         new Thread() {
             public void run() {
                 int count = retry;
                 while (count > 0) {
                     try {
                         // 根据过滤选项拼接请求URL
                         String requestURL = "";
                         if (searchType > 0) {
                             currSearchType = searchType;
                         }
                         switch (currSearchType) {
                         case SEARCH_TYPE_NEARBY:
                             requestURL = SEARCH_URI_NEARBY;
                             break;
                         case SEARCH_TYPE_LOCAL:
                             requestURL = SEARCH_URI_LOCAL;
                             break;
                         case SEARCH_TYPE_BOUND:
                             requestURL = SEARCH_URI_BOUND;
                             break;
                         case SEARCH_TYPE_DETAIL:
                             requestURL = SEARCH_URI_DETAIL;
                             break;
                         case SEARCH_TYPE_POI_LIST:
                             requestURL = SEARCH_URI_POI_LIST;
                             break;
                         default:
                             return;
                         }
                         requestURL += "ak=" + ak + "&geotable_id="
                                 + geotable_id;

                         String filter = null;
                         Iterator iter = filterParams.entrySet().iterator();
                         while (iter.hasNext()) {
                             Map.Entry entry = (Map.Entry) iter.next();
                             String key = entry.getKey().toString();
                             String value = entry.getValue().toString();

                             if (key.equals("filter")) {
                                 filter = value;
                             } else {
                                 if (key.equals("region")
                                         && currSearchType == SEARCH_TYPE_NEARBY) {
                                     continue;
                                 }
                                 requestURL = requestURL + "&" + key + "="
                                         + value;
                             }
                         }

                         if (filter != null && !filter.equals("")) {
                             // substring(3) 为了去掉"|" 的encode "%7C"
                             requestURL = requestURL + "&filter="
                                     + filter.substring(3);
                         }

                         Log.d("request url:", requestURL);

                         HttpGet httpRequest = new HttpGet(requestURL);
                         HttpClient httpClient = new DefaultHttpClient();
                         httpClient.getParams().setParameter(
                                 CoreConnectionPNames.CONNECTION_TIMEOUT,
                                 TIME_OUT);
                         httpClient.getParams().setParameter(
                                 CoreConnectionPNames.SO_TIMEOUT, TIME_OUT);

                         HttpProtocolParams.setUseExpectContinue(
                                 httpClient.getParams(), false);

                         String networkType = MapApplication.networkType;
                         if (networkType.equals("cmwap")) {
                             HttpHost proxy = new HttpHost(CMWAP_HOST, 80,
                                     "http");
                             httpClient.getParams().setParameter(
                                     ConnRoutePNames.DEFAULT_PROXY, proxy);
                         } else if (networkType.equals("ctwap")) {
                             HttpHost proxy = new HttpHost(CTWAP_HOST, 80,
                                     "http");
                             httpClient.getParams().setParameter(
                                     ConnRoutePNames.DEFAULT_PROXY, proxy);
                         }

                         // ((AbstractHttpClient)
                         // httpClient).getCookieSpecs().register("chinasource",
                         // new CookieSpecFactory() {
                         // public CookieSpec newInstance(HttpParams params) {
                         // return new LenientCookieSpec();
                         // }
                         // });
                         httpClient.getParams().setParameter(
                                 ClientPNames.COOKIE_POLICY,
                                 CookiePolicy.BROWSER_COMPATIBILITY);

                         HttpResponse httpResponse = httpClient
                                 .execute(httpRequest);
                         int status = httpResponse.getStatusLine()
                                 .getStatusCode();
                         if (status == HttpStatus.SC_OK) {
                             String result = EntityUtils.toString(
                                     httpResponse.getEntity(), "utf-8");
                             // Header a =
                             // httpResponse.getEntity().getContentType();
                             Message msgTmp = handler
                                     .obtainMessage(MapActivity.MSG_NET_SUCC);
                             msgTmp.obj = result;
                             msgTmp.arg1 = RESULT_GET;
                             msgTmp.sendToTarget();

                             break;
                         } else {
                             httpRequest.abort();
                             Message msgTmp = handler
                                     .obtainMessage(MapActivity.MSG_NET_STATUS_ERROR);
                             msgTmp.obj = "HttpStatus error";
                             msgTmp.sendToTarget();
                         }

                     } catch (Exception e) {
                         Log.e("request", "网络异常，请检查网络后重试！");
                         e.printStackTrace();
                     }

                     count--;
                 }

                 if (count <= 0 && handler != null) {
                     Message msgTmp = handler
                             .obtainMessage(MapActivity.MSG_NET_TIMEOUT);
                     msgTmp.sendToTarget();
                 }

                 Getting = false;

             }
         }.start();

         return true;
     }

     public static boolean searchNear(GeoPoint point, Handler handler) {
         return LBSCloud.request(LBSCloud.SEARCH_TYPE_NEARBY,
                 getRequestParams(point), handler);
     }

     private static HashMap<String, String> getRequestParams(GeoPoint point) {
         HashMap<String, String> map = new HashMap<String, String>();
         LocationModel lm = new LocationModel(point);
         map.put("q", "");
         map.put("location", lm.getLocation());
         map.put("radius", "100000");
         map.put("orderby", "create_date:-1");
         return map;
     }

     //写入的
     public static boolean postData(final int postType,
             final List<BasicNameValuePair> params) {
         if (params == null)
             return false;
         try {
             // 根据过滤选项拼接请求URL
             String requestURL = "";
             switch (postType) {
             case POST_TYPE_CREATE:
                 requestURL = POST_URI_CREATE;
                 break;
             case POST_TYPE_UPDATE:
                 requestURL = POST_URI_UPDATE;
                 break;
             case POST_TYPE_DELETE:
                 requestURL = POST_URI_DELETE;
                 break;
             default:
                 return false;
             }

             Log.d("request url:", requestURL);
             params.add(new BasicNameValuePair("geotable_id", geotable_id));
             params.add(new BasicNameValuePair("ak", ak));

             HttpPost httpPost = new HttpPost(requestURL);
             httpPost.setEntity(new UrlEncodedFormEntity(params, "utf-8"));

             HttpClient httpClient = new DefaultHttpClient();
             httpClient.getParams().setParameter(
                     CoreConnectionPNames.CONNECTION_TIMEOUT, TIME_OUT);
             httpClient.getParams().setParameter(
                     CoreConnectionPNames.SO_TIMEOUT, TIME_OUT);
             HttpProtocolParams.setUseExpectContinue(httpClient.getParams(),
                     false);

             String networkType = MapApplication.networkType;
             if (networkType.equals("cmwap")) {
                 HttpHost proxy = new HttpHost(CMWAP_HOST, 80, "http");
                 httpClient.getParams().setParameter(
                         ConnRoutePNames.DEFAULT_PROXY, proxy);
             } else if (networkType.equals("ctwap")) {
                 HttpHost proxy = new HttpHost(CTWAP_HOST, 80, "http");
                 httpClient.getParams().setParameter(
                         ConnRoutePNames.DEFAULT_PROXY, proxy);
             }
             httpClient.getParams().setParameter(ClientPNames.COOKIE_POLICY,
                     CookiePolicy.BROWSER_COMPATIBILITY);
             HttpResponse httpResponse = httpClient.execute(httpPost);
             int status = httpResponse.getStatusLine().getStatusCode();
             if (status == HttpStatus.SC_OK) {
                 String resp = EntityUtils.toString(httpResponse.getEntity(),
                         "utf-8");
                 Log.v("KKHP", resp);
                 JSONObject jsonObject = new JSONObject(resp);
                 String statuscode = jsonObject.getString("status");
                 String statusmsg = jsonObject.getString("message");
                 int liret = Integer.parseInt(statuscode);
                 // 0:成功
                 switch(liret){
                 case 0:
                 case 21:
                     return true;
                 default:
                     Log.e("Post", statusmsg);
                 }
             } else {
                 httpPost.abort();
             }
         } catch (Exception e) {
             Log.e("Post", "网络异常，请检查网络后重试！");
             e.printStackTrace();
         }
         return false;
     }

     public static boolean deletePoi() {
         List<BasicNameValuePair> list = new ArrayList<BasicNameValuePair>();
         //http://api.map.baidu.com/geodata/v2/column/update
         //phone must be set is_index_field = 1
         list.add(new BasicNameValuePair("phone", MapApplication.phoneNumber));

         return postData(POST_TYPE_DELETE, list);
     }

     public static boolean createPoi(BDLocation location) {
         //delete first
         deletePoi();

         return postData(POST_TYPE_CREATE, getPostParams(location));
     }

     private static List<BasicNameValuePair> getPostParams(BDLocation location) {

         List<BasicNameValuePair> list = new ArrayList<BasicNameValuePair>();

         list.add(new BasicNameValuePair("latitude", String.valueOf(location
                 .getLatitude())));
         list.add(new BasicNameValuePair("longitude", String.valueOf(location
                 .getLongitude())));
         //if (location.hasAddr()) {
             list.add(new BasicNameValuePair("address", location.getAddrStr()));
         //}
         list.add(new BasicNameValuePair("phone", MapApplication.phoneNumber));
         list.add(new BasicNameValuePair("locate_date", MyDatabase
                 .getCurrentTime()));

         list.add(new BasicNameValuePair("title", MapApplication.title));
         list.add(new BasicNameValuePair("sex", MapApplication.sex));
         list.add(new BasicNameValuePair("head", ""));
         list.add(new BasicNameValuePair("coord_type", coord_type));

         return list;
     }
 }
     

主要是两个函数，一个读request，一个写postdata（包括保存、更新和删除），其中读操作参考了网上一些资料，写操作网上找不到合用的资料，主要是自己硺磨出来的
为了调用方便，另外写了一些函数，这样调用就简单了，比如：LBSCloud.createPoi(location)就保存一个位置到网上数据表中去了，LBSCloud.searchNear(myPoint, mHandler)就查找附近的人了，mHandler里处理结果，如：

private final Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MSG_NET_TIMEOUT:
                break;
            case MSG_NET_STATUS_ERROR:
                break;
            case MSG_NET_SUCC:
                if(msg.arg1==LBSCloud.RESULT_GET){
                    String result = msg.obj.toString();
                    try {
                        JSONObject json = new JSONObject(result);
                        parse(json);
                    } catch (JSONException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;
            }
        }
    };

/*
     * 解析返回数据
     */
    private void parse(JSONObject json) {
        List<String> list = new ArrayList<String>();
        try {
            int status = json.getInt("status");
            Log.d("Status", ""+status);
            if(status!=0){
                return;
            }
            //int total = json.getInt("total");
            JSONArray jsonArray;
            try{
                jsonArray = json.getJSONArray("pois");
            }catch(JSONException e){
                jsonArray = json.getJSONArray("contents");
            }
            if (jsonArray != null && jsonArray.length() <= 0) {
                Toast.makeText(this, R.string.msg_search_near, Toast.LENGTH_SHORT).show();
            } else {
                points.clear();
                for (int i = 0; i < jsonArray.length(); i++) {
                    JSONObject jsonObj = (JSONObject) jsonArray.opt(i);
                    String phone, address;
                    try{
                        phone = jsonObj.getString("phone");
                    }catch(JSONException e){
                        Log.e("get phone error", e.getMessage());
                        continue;
                    }
                    //same body just show one time!
                    if(list.contains(phone))
                        continue;

                    //need not show myself!
                    if(phone.equals(MapApplication.phoneNumber))
                        continue;

                    list.add(phone);
                    try{
                        address = jsonObj.getString("address");
                    } catch(JSONException e){
                        address = jsonObj.getString("province") +
                                jsonObj.getString("city") +
                                jsonObj.getString("district");
                    }
                                        JSONArray locArray = jsonObj.getJSONArray("location");
                    double longitude = locArray.getDouble(0);
                    double latitude = locArray.getDouble(1);

                    LocationModel lm = new LocationModel(longitude, latitude);
                    lm.setPhone(phone);
                    lm.setAddr(address);
                    lm.setSex(jsonObj.getString("sex"));
                    lm.setHead(jsonObj.getString("head"));
                    lm.setName(jsonObj.getString("title"));
                    lm.setLocateDate(jsonObj.getString("locate_date"));
                    lm.setUpload(true);
                    points.add(lm);
                }
                addItemizedOverlay();
            }
        } catch (JSONException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

软件大概是这个样子：

这个 功能还在改进中，有时间将整理出整个软件设计思路来公诸同好！