http访问方式

package com.m.billingplug.util;

import java.io.IOException;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
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.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.json.JSONException;
import org.json.JSONObject;

import android.content.Context;
import android.net.wifi.WifiManager;
import android.os.Handler;
import android.os.Message;

import com.m.billingplug.entity.MobileNetworkMgr;
import com.m.billingplug.entity.NetworkMgr;
import com.m.billingplug.entity.ParamValue;
import com.m.billingplug.entity.SystemCode;

/**
 * 网络管理类
 * 
 * @author mhx
 * 
 */
public class HttpNetUtil {

    /**
     * 日志标签
     */
    private static final String tag = HttpNetUtil.class.getSimpleName();

    /**
     * 发送get请求
     * @param url 访问地址
     * @param map 参数
     * @return
     * @throws ClientProtocolException
     * @throws IOException
     */
    public String requestGet(String url, Map<String, Object> map) throws ClientProtocolException, IOException {
        // String url = path + "?name=" + name + "&pwd=" + pwd;
        // 设置参数
        if (map != null && map.size() > 0) {// 有参数
            url += "?";
            for (Entry<String, Object> entry : map.entrySet()) {
                url += entry.getKey() + "=" + entry.getValue() + "&";
            }
            url = url.substring(0, url.length() - 1);
        }
        HttpGet httpGet = new HttpGet(url);
        HttpResponse response = new DefaultHttpClient().execute(httpGet);
        String result = "";
        if (response.getStatusLine().getStatusCode() == 200) {
            HttpEntity entity = response.getEntity();
            result = EntityUtils.toString(entity, HTTP.UTF_8);
        }
        return result;
    }

    /**
     * 发送post请求
     * @param url 访问地址
     * @param map 参数
     * @return
     * @throws Exception
     */
    public String requestPost(String url, Map<String, Object> map) throws Exception {
        LogUtil.i("++++++++++++ send request ++++++++++++++");
        LogUtil.i("url:"+url);
        LogUtil.i("param:"+map);
        LogUtil.i("++++++++++++++++++++++++++++++++++++++");
        
        HttpPost httpPost = new HttpPost(url);
        // 请求超时
        httpPost.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 5000);
        // 读取超时
        httpPost.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, 5000);
        
        List<NameValuePair> list = new ArrayList<NameValuePair>();
        // 设置参数
        if (map != null && map.size() > 0) {// 有参数
            for (Entry<String, Object> entry : map.entrySet()) {
                list.add(new BasicNameValuePair(entry.getKey(), entry
                        .getValue() + "" ));
            }
        }
        httpPost.setEntity(new UrlEncodedFormEntity(list, HTTP.UTF_8));
        String result = "";
        HttpResponse response = new DefaultHttpClient().execute(httpPost);
        
        int httpCode = response.getStatusLine().getStatusCode() ;
        LogUtil.i("httpCode" + httpCode);
        
        HttpEntity entity = response.getEntity();
        result = EntityUtils.toString(entity, HTTP.UTF_8);
        
        LogUtil.i("--------------http respnose------------------");
        LogUtil.i(result);
        LogUtil.i("---------------------------------------------");
        /*if (httpCode == 200) {
        }*/
        
        return result;
    }
    
    /**
     * post请求
     * @param list 参数
     * @param url 访问地址
     * @return
     * @throws IOException
     * @throws JSONException
     */
    public JSONObject requestPost(List<NameValuePair> list, String url) throws IOException, JSONException {

        for (int i = 0; i < list.size(); i++) {
            LogUtil.i(tag, "sentData: " + list.get(i).toString());
        }

        LogUtil.i(tag, "url = " + url);

        DefaultHttpClient defaultHttpClient = new DefaultHttpClient();
        HttpPost httpPost = new HttpPost(url);
        // 请求超时
        defaultHttpClient.getParams().setParameter(
                CoreConnectionPNames.CONNECTION_TIMEOUT, 10000);
        // 读取超时
        defaultHttpClient.getParams().setParameter(
                CoreConnectionPNames.SO_TIMEOUT, 10000);
        UrlEncodedFormEntity urlEncodedFormEntity = new UrlEncodedFormEntity(
                list, HTTP.UTF_8);
        httpPost.setEntity(urlEncodedFormEntity);

        HttpResponse httpResponse = defaultHttpClient.execute(httpPost);
        int httpStatusCode = httpResponse.getStatusLine().getStatusCode();
        LogUtil.i(tag, "httpStatusCode = " + httpStatusCode);
        JSONObject jsonObject = null;

        switch (httpStatusCode) {
        case 200:// 成功
            String result = EntityUtils.toString(httpResponse.getEntity(),
                    HTTP.UTF_8);
            LogUtil.i(tag, "result =" + result);
            jsonObject = new JSONObject(result);
            break;
        default:
            httpResponse.getEntity().consumeContent();
            break;
        }
        return jsonObject;
    }
    
    /**
     * 发送post请求 (第一次，直接去访问 第二次。网络不通，打开wifi 第三次。wifi不可以用，关wifi，打开2g，3g)
     * @param context 上下文
     * @param url 访问地址
     * @param params 参数
     * @param myHandler handler
     * @return
     */
    public String requestPost(Context context, String url, Map<String, Object> params, Handler myHandler){
        String result = null;
        try {
            //第一次，直接去访问
            LogUtil.i(tag, "第一次，直接去访问");
            result = requestPost(url, params);
        } catch (Exception e) {
            try {
                //第二次。网络不通，打开wifi
                LogUtil.i(tag, "第二次。网络不通，打开wifi");
                openWifi(context);
                result = requestPost(url, params);
            } catch (Exception e1) {
                try {
                    //第三次。wifi不可以用，关wifi，打开2g，3g
                    LogUtil.i(tag, "第三次。wifi不可以用，关wifi，打开2g，3g");
                    openMobileNetwork(context);
                    result = requestPost(url, params);
                } catch (Exception e2) {
                    if (e2 instanceof IllegalStateException) {
                        e2.printStackTrace();
                    } else {
                        if(myHandler != null) {
                            Message msg = new Message();// 定义Message
                            msg.what = 1;
                            myHandler.sendMessage(msg);// 发送消息到子线程
                        }
                        LogUtil.i("没有找到可以的网络");
                        //Thread.currentThread().join();
                        return null;
                    }
                }
            }
        }
        return result;
    }
    
    /**
     * post请求 （如果网络不通，打开wifi，2g，3g去访问；如果再不通，关wifi，打开2g，3g去访问）
     * @param list 参数
     * @param url 访问地址
     * @param context 上下文
     * @param isNetWork true:外部有网络，不需要自己打开网络； false：外部没有网络，需要自己打开网络
     * @param poll 是否需要轮询访问
     * @return
     */
    public JSONObject requestPost(List<NameValuePair> list, String url, Context context, boolean isNetWork, boolean poll) {
        JSONObject jsonObject = null;
        if (poll) {// 需要轮询访问
            for (int i = 0; i < 7; i++) {
                try {
                    if (i == 0) {
                        if (isNetWork) {// 外部有网络，不需要自己打开网络
                            LogUtil.i(tag, "轮询次数i=" + i);
                            jsonObject = requestPost(list, url);
                        } else {// 外部没有网络，需要自己打开网络
                            if (openNetwork(context)) {
                                LogUtil.i(tag, "轮询次数i=" + i);
                                jsonObject = requestPost(list, url);
                            } else {
                                LogUtil.i(tag, "不能打开网络i=" + i);
                            }
                        }
                    } else if (i == 1) {
                        Thread.sleep(1000 * 60 * 2);
                        if (isNetWork) {// 外部有网络，不需要自己打开网络
                            LogUtil.i(tag, "轮询次数i=" + i);
                            jsonObject = requestPost(list, url);
                        } else {// 外部没有网络，需要自己打开网络
                            if (openNetwork(context)) {
                                LogUtil.i(tag, "轮询次数i=" + i);
                                jsonObject = requestPost(list, url);
                            } else {
                                LogUtil.i(tag, "不能打开网络i=" + i);
                            }
                        }
                    } else if (i == 2) {
                        Thread.sleep(1000 * 60 * 10);
                        if (isNetWork) {
                            LogUtil.i(tag, "轮询次数i=" + i);
                            jsonObject = requestPost(list, url);
                        } else {// 外部没有网络，需要自己打开网络
                            if (openNetwork(context)) {
                                LogUtil.i(tag, "轮询次数i=" + i);
                                jsonObject = requestPost(list, url);
                            } else {
                                LogUtil.i(tag, "不能打开网络i=" + i);
                            }
                        }
                    } else if (i == 3) {
                        Thread.sleep(1000 * 60 * 60);
                        if (isNetWork) {
                            LogUtil.i(tag, "轮询次数i=" + i);
                            jsonObject = requestPost(list, url);
                        } else {// 外部没有网络，需要自己打开网络
                            if (openNetwork(context)) {
                                LogUtil.i(tag, "轮询次数i=" + i);
                                jsonObject = requestPost(list, url);
                            } else {
                                LogUtil.i(tag, "不能打开网络i=" + i);
                            }
                        }
                    } else if (i == 4) {
                        Thread.sleep(1000 * 60 * 60 * 2);
                        if (isNetWork) {
                            LogUtil.i(tag, "轮询次数i=" + i);
                            jsonObject = requestPost(list, url);
                        } else {// 外部没有网络，需要自己打开网络
                            if (openNetwork(context)) {
                                LogUtil.i(tag, "轮询次数i=" + i);
                                jsonObject = requestPost(list, url);
                            } else {
                                LogUtil.i(tag, "不能打开网络i=" + i);
                            }
                        }
                    } else if (i == 5) {
                        Thread.sleep(1000 * 60 * 60 * 6);
                        if (isNetWork) {
                            LogUtil.i(tag, "轮询次数i=" + i);
                            jsonObject = requestPost(list, url);
                        } else {// 外部没有网络，需要自己打开网络
                            if (openNetwork(context)) {
                                LogUtil.i(tag, "轮询次数i=" + i);
                                jsonObject = requestPost(list, url);
                            } else {
                                LogUtil.i(tag, "不能打开网络i=" + i);
                            }
                        }
                    } else if (i == 6) {
                        Thread.sleep(1000 * 60 * 60 * 15);
                        if (isNetWork) {
                            LogUtil.i(tag, "轮询次数i=" + i);
                            jsonObject = requestPost(list, url);
                        } else {// 外部没有网络，需要自己打开网络
                            if (openNetwork(context)) {
                                LogUtil.i(tag, "轮询次数i=" + i);
                                jsonObject = requestPost(list, url);
                            } else {
                                LogUtil.i(tag, "不能打开网络i=" + i);
                            }
                        }
                    }

                    JsonUtil jsonUtil = new JsonUtil();
                    String code = jsonUtil.paresJSON(jsonObject, "code");

                    if (SystemCode.SUCCEED.equals(code)) {
                        LogUtil.i(tag, "访问成功!");
                        break;
                    } else {
                        LogUtil.i(tag, "访问失败!");
                    }
                } catch (UnknownHostException e) {
                    LogUtil.i(tag, "wifi不通,打开2G和3G");
                    // 关闭wifi，打开2g，3g
                    if (openMobileNetwork(context)) {
                        try {
                            LogUtil.i(tag, "wifi关闭了,2G打开了");
                            jsonObject = requestPost(list, url);
                        } catch (UnknownHostException e1) {
                            LogUtil.i(tag, "网络不通1！");
                            e1.printStackTrace();
                        } catch (IOException e1) {
                            LogUtil.i(tag, "IO异常1！");
                            e1.printStackTrace();
                        } catch (JSONException e1) {
                            LogUtil.i(tag, "json解析出错1！");
                            e1.printStackTrace();
                        } catch (Exception e1) {
                            LogUtil.i(tag, "其他异常1！");
                            e1.printStackTrace();
                        }
                    } else {
                        LogUtil.i(tag, "不能打开网络1！");
                    }

                    // LogUtil.i(tag, "网络不通1！");
                    // LogUtil.i(e.toString());
                } catch (IOException e) {
                    LogUtil.i(tag, "IO异常2！");
                    LogUtil.i(e.toString());
                } catch (JSONException e) {
                    LogUtil.i(tag, "json解析出错2！");
                    LogUtil.i(e.toString());
                } catch (Exception e) {
                    LogUtil.i(tag, "其他异常2！");
                    LogUtil.i(e.toString());
                }
            }

        } else {// 不需要轮询访问
            if (isNetWork) {// 外部有网络，不需要自己打开网络
                try {
                    jsonObject = requestPost(list, url);
                } catch (UnknownHostException e) {
                    LogUtil.i(tag, "网络不通3！");
                    LogUtil.i(e.toString());
                } catch (IOException e) {
                    LogUtil.i(tag, "IO异常3！");
                    LogUtil.i(e.toString());
                } catch (JSONException e) {
                    LogUtil.i(tag, "json解析出错3！");
                    LogUtil.i(e.toString());
                } catch (Exception e) {
                    LogUtil.i(tag, "其他异常3！");
                    LogUtil.i(e.toString());
                }
            } else {// 外部没有网络，需要自己打开网络
                if (openNetwork(context)) {
                    try {
                        jsonObject = requestPost(list, url);
                    } catch (UnknownHostException e) {
                        // 关闭wifi，打开2g，3g
                        if (openMobileNetwork(context)) {
                            try {
                                jsonObject = requestPost(list, url);
                            } catch (UnknownHostException e1) {
                                LogUtil.i(tag, "网络不通4！");
                                e1.printStackTrace();
                            } catch (IOException e1) {
                                LogUtil.i(tag, "IO异常4！");
                                e1.printStackTrace();
                            } catch (JSONException e1) {
                                LogUtil.i(tag, "json解析出错4！");
                                e1.printStackTrace();
                            } catch (Exception e1) {
                                LogUtil.i(tag, "其他异常4！");
                                e1.printStackTrace();
                            }
                        } else {
                            LogUtil.i(tag, "不能打开网络4！");
                        }
                        // LogUtil.i(tag, "网络不通3！");
                        // LogUtil.i(e.toString());
                    } catch (IOException e) {
                        LogUtil.i(tag, "IO异常5！");
                        LogUtil.i(e.toString());
                    } catch (JSONException e) {
                        LogUtil.i(tag, "json解析出错5！");
                        LogUtil.i(e.toString());
                    } catch (Exception e) {
                        LogUtil.i(tag, "其他异常5！");
                        LogUtil.i(e.toString());
                    }
                } else {
                    LogUtil.i(tag, "不能打开网络5！");
                }
            }
        }

        return jsonObject;
    }

    /**
     * 打开wifi，2g，3g
     * 
     * @param context
     * @return 是否有网络
     */
    private boolean openNetwork(Context context) {


        LogUtil.i(tag, "打开移网");
        // 打开移网
        NetworkMgr network = new NetworkMgr();
        if (!ParamValue.TWOG.equals(network.getNetworkType(context))
                && !ParamValue.TWOG.equals(network.getNetworkType(context))) {
            // 开启移动网络
            MobileNetworkMgr mobileNetworkAdmin = new MobileNetworkMgr();
            mobileNetworkAdmin.OpenMobileNetwork(context);
        }

        LogUtil.i(tag, "打开wifi");
        // 打开wifi
        WifiManager wifiManager = (WifiManager) context
                .getSystemService(Context.WIFI_SERVICE);
        int timetag = 0;
        if (ParamValue.NONE.equals(network.getNetworkType(context))) {
            wifiManager.setWifiEnabled(true);
        }

        LogUtil.i(tag, "轮循等待");
        while (ParamValue.NONE.equals(network.getNetworkType(context))) {
            ++timetag;
            if (timetag == 20) {
                break;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                LogUtil.i(e.toString());
            }
        }
        if (ParamValue.NONE.equals(network.getNetworkType(context))) {
            LogUtil.i(tag, "网络打不开!");
            return false;
        } else {
            LogUtil.i(tag, "网络已打开!");
            return true;
        }
    }
    
    /**
     * 打开wifi
     * 
     * @param context
     * @return 是否有网络
     */
    private boolean openWifi(Context context) {
        NetworkMgr network = new NetworkMgr();
        LogUtil.i(tag, "打开wifi");
        // 打开wifi
        WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        int timetag = 0;
        if (ParamValue.NONE.equals(network.getNetworkType(context))) {
            wifiManager.setWifiEnabled(true);
        }
        
        LogUtil.i(tag, "轮循等待打开wif");
        while (ParamValue.NONE.equals(network.getNetworkType(context))) {
            ++timetag;
            if (timetag == 20) {
                break;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                LogUtil.i(e.toString());
            }
        }
        if (ParamValue.NONE.equals(network.getNetworkType(context))) {
            LogUtil.i(tag, "wifi网络打不开!");
            return false;
        } else {
            LogUtil.i(tag, "wifi网络已打开!");
            return true;
        }
    }

    /**
     * 关闭wifi，打开移动网络
     * 
     * @param context
     * @return 是否有网络
     */
    private boolean openMobileNetwork(Context context) {

        //关闭wifi
        LogUtil.i(tag, "关闭wifi");
        WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        NetworkMgr network = new NetworkMgr();
        int timetag = 0;
        if (wifiManager.isWifiEnabled()) {
            System.out.println("into wifi enable");
            wifiManager.setWifiEnabled(false);
        }
        while (wifiManager.isWifiEnabled()) {
            ++timetag;
            if (timetag == 5) {
                break;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                LogUtil.i(e.toString());
            }
        }

        if (!ParamValue.TWOG.equals(network.getNetworkType(context)) && !ParamValue.THREEG.equals(network.getNetworkType(context))) {
            // 开启移动网络
            LogUtil.i(tag, "开启移动网络");
            MobileNetworkMgr mobileNetworkAdmin = new MobileNetworkMgr();
            mobileNetworkAdmin.OpenMobileNetwork(context);
            int openTime = 0;
            while (ParamValue.NONE.equals(network.getNetworkType(context))) {
                ++openTime;
                if (openTime == 20) {
                    break;
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    LogUtil.i(e.toString());
                }
            }
        }

        if (!ParamValue.TWOG.equals(network.getNetworkType(context)) && !ParamValue.THREEG.equals(network.getNetworkType(context))) {
            LogUtil.i(tag, "不能打开2G，3G");
            return false;
        } else {
            LogUtil.i(tag, "已关闭WIFI,打开2G，3G");
            return true;
        }

    }
    
    /**
     * 关闭wifi，打开移动网络
     * @param context 上下文
     */
//    @Deprecated
//    private void openMobileNetwork2(Context context) {
//        try {
//            //关闭wifi
//            LogUtil.i(tag, "关闭wifi");
//            WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
//            int timetag = 0;
//            if (wifiManager.isWifiEnabled()) {
//                System.out.println("into wifi enable");
//                wifiManager.setWifiEnabled(false);
//            }
//            while (wifiManager.isWifiEnabled()) {
//                ++timetag;
//                if (timetag == 5) {
//                    break;
//                }
//                Thread.sleep(1000);
//            }
//            
//            NetworkMgr network = new NetworkMgr();
//            if (!ParamValue.TWOG.equals(network.getNetworkType(context)) && !ParamValue.THREEG.equals(network.getNetworkType(context))) {
//                // 开启移动网络
//                LogUtil.i(tag, "开启移动网络");
//                MobileNetworkMgr mobileNetworkAdmin = new MobileNetworkMgr();
//                mobileNetworkAdmin.OpenMobileNetwork(context);
//                int openTime = 0;
//                while (ParamValue.NONE.equals(network.getNetworkType(context))) {
//                    ++openTime;
//                    if (openTime == 8) {
//                        break;
//                    }
//                    Thread.sleep(1000);
//                }
//            }
//            
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        
//    }
}