网络相关的工具类

╰+哭是因爲堅強的太久メ 2022-08-21 04:59 208阅读 0赞

package com.companyname.sdp.sce.tvappstore.utils;  
  
import java.io.BufferedInputStream;  
import java.io.BufferedOutputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.File;  
import java.io.FileFilter;  
import java.io.FileOutputStream;  
import java.io.FilenameFilter;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
import java.io.UnsupportedEncodingException;  
import java.lang.reflect.Method;  
import java.net.HttpURLConnection;  
import java.net.InetAddress;  
import java.net.MalformedURLException;  
import java.net.NetworkInterface;  
import java.net.SocketException;  
import java.net.URL;  
import java.util.Arrays;  
import java.util.Enumeration;  
import java.util.List;  
  
import org.apache.http.HttpEntity;  
import org.apache.http.HttpResponse;  
import org.apache.http.HttpStatus;  
import org.apache.http.NameValuePair;  
import org.apache.http.client.ClientProtocolException;  
import org.apache.http.client.HttpClient;  
import org.apache.http.client.entity.UrlEncodedFormEntity;  
import org.apache.http.client.methods.HttpPost;  
import org.apache.http.conn.util.InetAddressUtils;  
import org.apache.http.util.EntityUtils;  
import org.json.JSONException;  
import org.json.JSONObject;  
  
import android.annotation.SuppressLint;  
import android.annotation.TargetApi;  
import android.content.Context;  
import android.content.pm.PackageInfo;  
import android.content.pm.PackageManager.NameNotFoundException;  
import android.graphics.Bitmap;  
import android.graphics.Bitmap.CompressFormat;  
import android.graphics.BitmapFactory;  
import android.net.ConnectivityManager;  
import android.net.NetworkInfo;  
import android.os.AsyncTask;  
import android.os.Build;  
import android.text.TextUtils;  
import android.util.Log;  
  
import com.companyname.sdp.sce.tvappstore.constant.Constant;  
import com.companyname.sdp.sce.tvappstore.log.ILog;  
  
@TargetApi(Build.VERSION\_CODES.GINGERBREAD)  
public final class Tools \{  
    public static final String TAG = "Tools";  
  
    public static final String SD\_CARD\_PATH\_APPSTORE = "appstore"  
            + File.separator;  
  
    public static final String SD\_CARD\_PATH\_IMG\_CACHE = SD\_CARD\_PATH\_APPSTORE  
            + "img" + File.separator;  
  
    public static final int CONNECT\_TIMEOUT = 30000;  
    public static final int READ\_TIMEOUT = 30000;  
  
    public static final int BYTE = 1024;  
  
    /\*\*  
     \* 获得网络的json对象  
     \*  
     \* @param path  
     \*            网络json地址  
     \* @return JSONObject  
     \* @throws Exception  
     \*/  
    public static JSONObject getHttpJsonObject(String path) throws Exception \{  
        String json = "";  
        HttpURLConnection conn = null;  
        Log.v(TAG, "path=" + path);  
        conn = getHttpUrlConn(path);  
        conn.connect();  
        if (200 == conn.getResponseCode()) \{  
            InputStream inStream = null;  
            inStream = conn.getInputStream();  
            byte\[\] data = null;  
            data = Tools.readInputStream(inStream);  
            if (conn != null) \{  
                conn.disconnect();  
            \}  
            json = new String(data);  
        \}  
        else\{  
            json = new String("\{respseStatus:-1,respseDesc:failure,resultObject: null\}");  
        \}  
        if (conn != null) \{  
            conn.disconnect();  
        \}  
        Log.d(TAG, "json=" + json);  
        return new JSONObject(json);  
    \}  
  
    /\*\*  
     \* 发送数据  
     \*  
     \* @param path  
     \* @return  
     \* @throws MalformedURLException  
     \* @throws IOException  
     \*/  
    public static boolean sendData(String path) throws MalformedURLException,  
            IOException \{  
        boolean ret = false;  
        HttpURLConnection conn = null;  
        conn = getHttpUrlConn(path);  
        conn.connect();  
        if (200 == conn.getResponseCode()) \{  
            ret = true;  
        \}  
        if (conn != null) \{  
            conn.disconnect();  
        \}  
        return ret;  
    \}  
  
    /\*\*  
     \* 建立url连接  
     \*  
     \* @param path  
     \* @return  
     \* @throws MalformedURLException  
     \* @throws IOException  
     \*/  
    public static HttpURLConnection getHttpUrlConn(String path)  
            throws MalformedURLException, IOException \{  
        URL url = new URL(path);  
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
        conn.setConnectTimeout(CONNECT\_TIMEOUT);  
        conn.setReadTimeout(READ\_TIMEOUT);  
        conn.setRequestMethod("GET");  
        return conn;  
    \}  
  
    /\*\*  
     \* 发送数据到服务器  
     \*  
     \* @param path  
     \*            服务器地址  
     \* @param params  
     \*            内容参数  
     \* @return 结果标示  
     \*/  
    public static JSONObject sendPost(String path, List<NameValuePair> params) \{  
        JSONObject resObject = null;  
        String strResult = null;  
        // HttpPost连接对象  
        HttpPost httpRequest = null;  
        HttpEntity httpEntity = null;  
        HttpClient httpClient = null;  
        try \{  
            httpRequest = new HttpPost(path);  
            httpEntity = new UrlEncodedFormEntity(params, "UTF-8");  
            // 请求httpRequest  
            httpRequest.setEntity(httpEntity);  
            // 取得HttpClient  
            httpClient = CustomerHttpClient.getHttpClient();  
            // 取得HttpResponse  
            HttpResponse httpResponse = httpClient.execute(httpRequest);  
            // HttpStatus.SC\_OK表示连接成功  
            if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC\_OK) \{  
                // 取得返回的字符串  
                strResult = EntityUtils.toString(httpResponse.getEntity());  
                resObject = new JSONObject(strResult);  
            \}  
        \} catch (UnsupportedEncodingException e) \{  
            e.printStackTrace();  
        \} catch (ClientProtocolException e) \{  
            e.printStackTrace();  
        \} catch (IOException e) \{  
            e.printStackTrace();  
        \} catch (JSONException e) \{  
            e.printStackTrace();  
        \}  
        return resObject;  
    \}  
  
    /\*\*  
     \* 从输入流中获取数据  
     \*  
     \* @param inStream  
     \*            输入流  
     \* @return  
     \* @throws IOException  
     \*/  
    private static byte\[\] readInputStream(InputStream inStream)  
            throws IOException \{  
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();  
        byte\[\] buffer = new byte\[Tools.BYTE\];  
        int len = 0;  
        while ((len = inStream.read(buffer)) != -1) \{  
            outStream.write(buffer, 0, len);  
        \}  
        inStream.close();  
        return outStream.toByteArray();  
    \}  
  
    /\*\*  
     \* 检查网络是否为空  
     \*  
     \* @param context  
     \* @return  
     \*/  
    public static boolean isNetworkAvailable(Context context) \{  
        final ConnectivityManager cm = (ConnectivityManager) context  
                .getSystemService(Context.CONNECTIVITY\_SERVICE);  
        final NetworkInfo networkInfo = cm.getActiveNetworkInfo();  
        if (networkInfo == null || !networkInfo.isConnectedOrConnecting()) \{  
            return false;  
        \}  
        return true;  
    \}  
  
    public static String getClientUpdateUrl(Context context) \{  
        String resultStr = "null";  
        try \{  
  
            int osVersion = android.os.Build.VERSION.SDK\_INT;  
            ILog.dPrint(TAG, "osVersion " + osVersion);  
            PackageInfo info;  
            info = context.getPackageManager().getPackageInfo(  
                    context.getPackageName(), 0);  
            String device = Build.DEVICE;  
            String path = Constant.URLUtil.sAPP\_CLIENT\_UPDATE\_CHECK  
                    + "osVersion=" + osVersion + "&appStoreVersion="  
                    + info.versionCode + "&clientModel=" + device;  
  
            JSONObject retObj = Tools.getHttpJsonObject(path);  
            ILog.dPrint(TAG, "retObj = " + retObj);  
            if (retObj == null  
                    || Constant.sFAILED == Integer.parseInt(retObj  
                            .getString(Constant.sRESPSE\_STATUS))) \{  
                return resultStr;  
            \}  
            resultStr = retObj.getString(Constant.sRESULT\_OBJECT);  
        \} catch (NumberFormatException e) \{  
            e.printStackTrace();  
        \} catch (NameNotFoundException e) \{  
            e.printStackTrace();  
        \} catch (JSONException e) \{  
            e.printStackTrace();  
        \} catch (Exception e) \{  
            e.printStackTrace();  
        \}  
        return resultStr;  
    \}  
  
    /\*\*  
     \* 获取系统配置文件中属性值  
     \*  
     \* @param key  
     \* @param defaultvalue  
     \* @return  
     \*/  
    public static String getProperties(String key, String defaultvalue) \{  
        String Value = null;  
        Class<?> systemPropertiesClass = null;  
        Method method = null;  
        try \{  
            systemPropertiesClass = Class  
                    .forName("android.os.SystemProperties");  
            Class<?> getType\[\] = new Class\[2\];  
            getType\[0\] = String.class;  
            getType\[1\] = String.class;  
            method = systemPropertiesClass.getMethod("get", getType);  
            Object arglist\[\] = new Object\[2\];  
            arglist\[0\] = key;  
            arglist\[1\] = defaultvalue;  
            Object receiver = new Object();  
            Object retVal = method.invoke(receiver, arglist);  
            if (receiver != null) \{  
                Value = (String) retVal;  
            \}  
        \} catch (Exception e) \{  
            e.printStackTrace();  
        \}  
        return Value;  
    \}  
  
    /\*\*  
     \* 设置系统配置文件中属性值  
     \*  
     \* @param key  
     \* @param value  
     \* @return  
     \*/  
    public static void setProperties(String key, String value) \{  
        Class<?> systemPropertiesClass = null;  
        Method method = null;  
        try \{  
            systemPropertiesClass = Class  
                    .forName("android.os.SystemProperties");  
            Class<?> getType\[\] = new Class\[2\];  
            getType\[0\] = String.class;  
            getType\[1\] = String.class;  
            method = systemPropertiesClass.getMethod("set", getType);  
            Object arglist\[\] = new Object\[2\];  
            arglist\[0\] = key;  
            arglist\[1\] = value;  
            Object receiver = new Object();  
            method.invoke(receiver, arglist);  
        \} catch (Exception e) \{  
            e.printStackTrace();  
        \}  
    \}  
  
    /\*\*  
     \* ap和有线同时存在，多个ip的情况下  
     \*  
     \* @return  
     \*/  
    private static String getLocalIp() \{  
        try \{  
            for (Enumeration<NetworkInterface> en = NetworkInterface  
                    .getNetworkInterfaces(); en.hasMoreElements();) \{  
                NetworkInterface intf = en.nextElement();  
                for (Enumeration<InetAddress> enumIpAddr = intf  
                        .getInetAddresses(); enumIpAddr.hasMoreElements();) \{  
                    InetAddress inetAddress = enumIpAddr.nextElement();  
                    Log.e("gdgfd", "1111111111 ip ==="+inetAddress.getHostAddress().toString());  
                    if (!inetAddress.isLoopbackAddress()  
                            && InetAddressUtils.isIPv4Address(inetAddress  
                                    .getHostAddress())) \{  
                        return inetAddress.getHostAddress().toString();  
                    \}  
                \}  
            \}  
        \} catch (SocketException ex) \{  
            ILog.ePrint("WifiPreference IpAddress", ex.toString());  
        \}  
        return null;  
    \}  
  
    public static String getMac() \{  
        String mac\_s = "";  
        try \{  
            byte\[\] mac;  
            NetworkInterface ne = NetworkInterface.getByInetAddress(InetAddress  
                    .getByName(getLocalIp()));  
            mac = ne.getHardwareAddress();  
            mac\_s = byte2hex(mac);  
        \} catch (Exception e) \{  
            e.printStackTrace();  
        \}  
        return mac\_s;  
    \}  
  
    public static String getMyMac() \{  
        String mac\_s = "";  
        try \{  
            mac\_s = getProperties("persist.sys.eth\_mac", "");  
        \} catch (Exception e) \{  
            e.printStackTrace();  
        \}  
        return mac\_s;  
    \}  
  
    @SuppressLint("NewApi")  
    @TargetApi(Build.VERSION\_CODES.GINGERBREAD)  
    public static String byte2hex(byte\[\] b) \{  
        StringBuffer hs = new StringBuffer(b.length);  
        String stmp = "";  
        int len = b.length;  
        for (int n = 0; n < len; n++) \{  
            stmp = Integer.toHexString(b\[n\] & 0xFF);  
            if (stmp.length() == 1) \{  
                hs.append("0");  
                hs.append(stmp);  
            \} else \{  
                hs = hs.append(stmp);  
            \}  
        \}  
        return String.valueOf(hs);  
    \}  
      
    class GetLocalOrNetBitmap extends AsyncTask<String, String, Boolean>\{  
  
        @Override  
        protected Boolean doInBackground(String... arg0) \{  
            // TODO Auto-generated method stub  
            return null;  
        \}  
          
    \}  
  
    /\*\*  
     \* 得到本地或者网络上的bitmap url - 网络或者本地图片的绝对路径,比如:  
     \*  
     \* @param url  
     \* @param needCheckCache  
     \*            是否验证本地缓存  
     \* @return  
     \*/  
    public static Bitmap GetLocalOrNetBitmap(String url, String cachePath,  
            boolean needCheckCache) \{  
          
        if (needCheckCache && checkCache(url, cachePath)) \{  
            return getCacheBitmap(url, cachePath);  
        \}  
  
        String fileName = url.split("/")\[url.split("/").length - 1\];  
        String cacheFileName = fileName.split("\\\\.")\[0\] + ".0";  
  
        Log.e("909504", "save dir,cacheFileName: " + cachePath + ","  
                + cacheFileName);  
        Log.e("909504", "url: " + url);  
  
        Bitmap bitmap = null;  
        //InputStream in = null;  
        //BufferedOutputStream out = null;  
        try \{  
            //in = new BufferedInputStream(new URL(url).openStream(), 1024);  
            //final ByteArrayOutputStream dataStream = new ByteArrayOutputStream();  
            //out = new BufferedOutputStream(dataStream, 1024);  
            //copy(in, out);  
            //out.flush();  
            //byte\[\] data = dataStream.toByteArray();  
            //byte\[\] data = getImage(url);  
             BitmapFactory.Options options = new BitmapFactory.Options();  
             options.inSampleSize = 2;  
            //bitmap = BitmapFactory.decodeByteArray(data, 0, data.length,options);  
            bitmap = BitmapFactory.decodeStream(getImageStream(url), null, options);  
              
  
            // 将图片缓存, poster目录则不缓存  
            if (cachePath.indexOf(Constant.POSTER) <=0) \{  
                File file = new File(cachePath, cacheFileName);// 保存文件,  
                bitmap.compress(CompressFormat.PNG, 100, new FileOutputStream(  
                        file));  
            \}  
  
            //data = null;  
            //in.close();  
            //out.close();  
        \} catch (Exception e) \{  
            e.printStackTrace();  
            return null;  
        \}  
  
        return bitmap;  
    \}  
      
     /\*\*  
     \* Get image from newwork  
     \* @param path The path of image  
     \* @return byte\[\]  
     \* @throws Exception  
     \*/    
    public static byte\[\] getImage(String path) throws Exception\{    
        URL url = new URL(path);    
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();    
        conn.setConnectTimeout(5 \* 1000);    
        conn.setRequestMethod("GET");    
        InputStream inStream = conn.getInputStream();    
        if(conn.getResponseCode() == HttpURLConnection.HTTP\_OK)\{    
            return readStream(inStream);    
        \}    
        return null;    
    \}    
      
    public static byte\[\] readStream(InputStream inStream) throws Exception\{    
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();    
        byte\[\] buffer = new byte\[1024\];    
        int len = 0;    
        while( (len=inStream.read(buffer)) != -1)\{    
            outStream.write(buffer, 0, len);    
        \}    
        outStream.close();    
        inStream.close();    
        return outStream.toByteArray();    
    \}  
      
    /\*\*  
     \* Get image from newwork  
     \* @param path The path of image  
     \* @return InputStream  
     \* @throws Exception  
     \*/    
    public static InputStream getImageStream(String path) throws Exception\{    
        URL url = new URL(path);    
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();    
        conn.setConnectTimeout(8 \* 1000);    
        conn.setRequestMethod("GET");    
        if(conn.getResponseCode() == HttpURLConnection.HTTP\_OK)\{    
            return conn.getInputStream();    
        \}    
        return null;    
    \}    
  
    /\*  
     \* 检测本地/data/data/package/cache/...下是否有该图片  
     \*  
     \* @return true:存在 false：不存在  
     \*/  
    private static boolean checkCache(String url, String cachePath) \{  
        Log.d("909504", "start checkCache url = " + url);  
        try \{  
            String fileName = url.split("/")\[url.split("/").length - 1\];  
            String cacheFileName = fileName.split("\\\\.")\[0\] + ".0";  
  
            //Log.e("909504", "checkCache url's cacheFileName= " + cacheFileName);  
  
            File cacheFilePath = new File(cachePath);  
            String\[\] posterArr = cacheFilePath.list(new FilenameFilter() \{  
                @Override  
                public boolean accept(File parentFile, String fileName) \{  
                    return fileName.endsWith(".0");  
                \}  
            \});  
  
            if(posterArr == null || posterArr.length == 0)\{  
                return false;  
            \}  
            List<String> posterList = Arrays.asList(posterArr);  
  
            for (int i = 0; i < posterList.size(); i++) \{  
                //Log.e("909504", "posterList\[" + i + "\] = " + posterList.get(i));  
            \}  
  
            Log.d("909504", "posterList.contains( " + cacheFileName + ") = "  
                    + posterList.contains(cacheFileName));  
  
            return posterList.contains(cacheFileName);  
        \} catch (Exception e) \{  
            e.printStackTrace();  
        \} finally \{  
            Log.e("909504", "end checkCache url = " + url);  
        \}  
  
        return false;  
    \}  
  
    /\*  
     \* 获取/data/data/package/cache/...下的图片，并转化成bitmap  
     \*/  
    public static Bitmap getCacheBitmap(String url, String cachePath) \{  
  
        String fileName = url.split("/")\[url.split("/").length - 1\];  
        String cacheFileName = fileName.split("\\\\.")\[0\] + ".0";  
  
        // String posterUrl = "file://" + cachePath + File.separator  
        // + cacheFileName;  
          
          
  
        String path = cachePath + File.separator + cacheFileName;  
          
        Log.e("909504", "getCacheBitmap path: " + path);  
  
        File mfile = new File(path);  
        if (mfile.exists()) \{// 若该文件存在  
            Bitmap bm = BitmapFactory.decodeFile(path);  
            return bm;  
        \}  
  
        return null;  
    \}  
  
    private static void copy(InputStream in, OutputStream out)  
            throws IOException \{  
        byte\[\] b = new byte\[1024\];  
        int read;  
        while ((read = in.read(b)) != -1) \{  
            out.write(b, 0, read);  
        \}  
    \}  
\}