用信花 v1.1.3 - Util.java 源代码

package com.netease.cloud.nos.yidun.utils;

import android.content.Context;
import android.content.SharedPreferences;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Environment;
import android.preference.PreferenceManager;
import android.util.Base64;
import com.just.agentweb.DefaultWebClient;
import com.netease.cloud.nos.yidun.constants.Code;
import com.netease.cloud.nos.yidun.constants.Constants;
import com.netease.cloud.nos.yidun.core.Callback;
import com.netease.cloud.nos.yidun.core.WanAccelerator;
import com.netease.cloud.nos.yidun.core.WanNOSObject;
import com.netease.cloud.nos.yidun.exception.InvalidParameterException;
import com.netease.cloud.nos.yidun.http.HttpResult;
import e9.d0;
import e9.f0;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.net.URLEncoder;
import java.util.Enumeration;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import javax.net.ssl.SSLException;
import org.apache.http.conn.ConnectTimeoutException;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

public class Util {
    private static final String LOGTAG = LogUtil.makeLogTag(Util.class);

    public static CountDownLatch acquireLock() {
        return new CountDownLatch(1);
    }

    public static void addHeaders(f0.a aVar, WanNOSObject wanNOSObject) {
        if (wanNOSObject.getContentType() != null && !wanNOSObject.getContentType().equals("")) {
            aVar.a("Content-Type", wanNOSObject.getContentType());
        }
        if (wanNOSObject.getUserMetadata() == null || wanNOSObject.getUserMetadata().size() <= 0) {
            return;
        }
        Map<String, String> userMetadata = wanNOSObject.getUserMetadata();
        for (String str : userMetadata.keySet()) {
            aVar.a("x-nos-meta-" + str, userMetadata.get(str));
        }
    }

    public static String buildLBSUrl(String str, String str2) {
        LogUtil.d(LOGTAG, "query lbs url: " + str);
        return str + "?version=1.0&bucketname=" + str2;
    }

    public static String buildPostDataUrl(String str, String str2, String str3, String str4, long j, boolean z) {
        String str5;
        if (str4 != null) {
            str5 = encode(str2) + "/" + encode(str3) + "?version=1.0&context=" + str4 + "&offset=" + j + "&complete=" + z;
        } else {
            str5 = encode(str2) + "/" + encode(str3) + "?version=1.0&offset=" + j + "&complete=" + z;
        }
        LogUtil.d(LOGTAG, "post data url server: " + str + ", query string: " + str5);
        return str + "/" + str5;
    }

    public static String buildQueryUrl(String str, String str2, String str3, String str4) {
        String str5;
        if (str4 != null) {
            str5 = encode(str2) + "/" + encode(str3) + "?uploadContext&version=1.0&context=" + str4;
        } else {
            str5 = encode(str2) + "/" + encode(str3) + "?uploadContext&version=1.0";
        }
        return str + "/" + str5;
    }

    public static void checkParameters(Context context, Object obj, Object obj2, WanNOSObject wanNOSObject, Callback callback) {
        String uploadToken = wanNOSObject.getUploadToken();
        String nosBucketName = wanNOSObject.getNosBucketName();
        String nosObjectName = wanNOSObject.getNosObjectName();
        if (context == null || obj == null || obj2 == null || callback == null || uploadToken == null || nosBucketName == null || nosObjectName == null) {
            throw new InvalidParameterException("parameters could not be null");
        }
    }

    public static void closeInputStream(InputStream inputStream) {
        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
                LogUtil.e(LOGTAG, "Failed to close InputStream: " + e.getMessage());
            }
        }
    }

    public static void deleteTempFiles(Context context) {
        File[] listFiles;
        File file = new File(getSDPath(context).getPath() + Constants.TEMP_FILE);
        if (!file.exists() || (listFiles = file.listFiles()) == null) {
            return;
        }
        for (File file2 : listFiles) {
            file2.delete();
        }
    }

    private static String encode(String str) {
        return URLEncoder.encode(str, WanAccelerator.getConf().getCharset());
    }

    public static boolean getBooleanData(Context context, String str) {
        return getDefaultPreferences(context).getBoolean(str, false);
    }

    public static String getData(Context context, String str) {
        return getDefaultPreferences(context).getString(str, null);
    }

    private static SharedPreferences getDefaultPreferences(Context context) {
        return PreferenceManager.getDefaultSharedPreferences(context);
    }

    public static ExecutorService getExecutorService() {
        return Executors.newSingleThreadExecutor();
    }

    public static d0 getHttpClient(Context context) {
        return Http.getHttpClient(context);
    }

    public static int getHttpCode(HttpResult httpResult) {
        Exception exception;
        int statusCode = httpResult.getStatusCode();
        if (statusCode == 200 || (exception = httpResult.getException()) == null) {
            return statusCode;
        }
        if (exception instanceof ConnectTimeoutException) {
            LogUtil.d(LOGTAG, "connection timeout Exception:" + exception.getMessage());
            return Code.CONNECTION_TIMEOUT;
        }
        if (exception instanceof SocketTimeoutException) {
            LogUtil.d(LOGTAG, "Read Socket Timeout Exception:" + exception.getMessage());
            return Code.SOCKET_TIMEOUT;
        }
        if (exception instanceof SSLException) {
            LogUtil.d(LOGTAG, "SSL Exception:" + exception.getMessage());
            return Code.SSL_FAILED;
        }
        if (exception instanceof SocketException) {
            LogUtil.d(LOGTAG, "Socket Exception" + exception.getMessage());
            String lowerCase = exception.getMessage().toLowerCase();
            if (lowerCase.contains("refused")) {
                return Code.CONNECTION_REFUSED;
            }
            if (lowerCase.contains("reset")) {
                return Code.CONNECTION_RESET;
            }
        } else if (exception instanceof JSONException) {
            LogUtil.d(LOGTAG, "JSON Exception" + exception.getMessage());
            return Code.INVALID_RESPONSE_DATA;
        }
        return statusCode;
    }

    public static String getIPAddress() {
        try {
            Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
            while (networkInterfaces.hasMoreElements()) {
                Enumeration<InetAddress> inetAddresses = networkInterfaces.nextElement().getInetAddresses();
                while (inetAddresses.hasMoreElements()) {
                    InetAddress nextElement = inetAddresses.nextElement();
                    if (!nextElement.isLoopbackAddress() && (nextElement instanceof Inet4Address)) {
                        return nextElement.getHostAddress();
                    }
                }
            }
            return "";
        } catch (SocketException unused) {
            LogUtil.e(LOGTAG, "get ip address socket exception");
            return "";
        }
    }

    public static String getIPString(String str) {
        if (str == null || str.equals("")) {
            return "";
        }
        if (str.startsWith("https")) {
            str = str.replaceAll(DefaultWebClient.HTTPS_SCHEME, "");
        }
        if (str.startsWith("http")) {
            str = str.replaceAll(DefaultWebClient.HTTP_SCHEME, "");
        }
        return str.replaceAll("^(\\d{1,3}(\\.\\d{1,3}){3}).*", "$1");
    }

    public static int getIntData(Context context, String str) {
        return getDefaultPreferences(context).getInt(str, 0);
    }

    public static d0 getLbsHttpClient(Context context) {
        return Http.getLbsHttpClient(context);
    }

    public static long getLongData(Context context, String str) {
        return getDefaultPreferences(context).getLong(str, 0L);
    }

    public static String getMonitorUrl(String str) {
        return str + "/stat/sdk?version=1.0";
    }

    public static String getResultString(HttpResult httpResult, String str) {
        if (httpResult != null && httpResult.getMsg() != null && httpResult.getMsg().has(str)) {
            try {
                return httpResult.getMsg().getString(str);
            } catch (JSONException e) {
                LogUtil.e(LOGTAG, "get result string parse json failed", e);
            }
        }
        return "";
    }

    public static File getSDPath(Context context) {
        return Environment.getExternalStorageState().equals("mounted") ? Environment.getExternalStorageDirectory() : context.getCacheDir();
    }

    public static String getToken(String str, String str2, long j, String str3, String str4, String str5, String str6) {
        JSONObject jSONObject = new JSONObject();
        if (str != null) {
            jSONObject.put("Bucket", str);
        }
        if (str2 != null) {
            jSONObject.put("Object", str2);
        }
        if (j != 0) {
            jSONObject.put("Expires", j);
        }
        if (str5 != null) {
            jSONObject.put("CallbackUrl", str5);
        }
        if (str6 != null) {
            jSONObject.put("CallbackBody", str6);
        }
        String str7 = new String(Base64.encode(jSONObject.toString().getBytes(), 2));
        SecretKeySpec secretKeySpec = new SecretKeySpec(str4.getBytes(), "HmacSHA256");
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(secretKeySpec);
        return "UPLOAD " + str3 + ":" + new String(Base64.encode(mac.doFinal(str7.getBytes()), 2)) + ":" + str7;
    }

    public static String[] getUploadServer(Context context, String str, boolean z) {
        String data;
        if (z) {
            data = getData(context, str + Constants.HTTPS_UPLOAD_SERVER_KEY);
        } else {
            data = getData(context, str + Constants.UPLOAD_SERVER_KEY);
        }
        if (data == null) {
            return null;
        }
        return data.split(";");
    }

    public static long ipToLong(String str) {
        if (str == null || str.equals("")) {
            return 0L;
        }
        int indexOf = str.indexOf(".");
        int i = indexOf + 1;
        int indexOf2 = str.indexOf(".", i);
        int i3 = indexOf2 + 1;
        int indexOf3 = str.indexOf(".", i3);
        long[] jArr = {Long.parseLong(str.substring(0, indexOf)), Long.parseLong(str.substring(i, indexOf2)), Long.parseLong(str.substring(i3, indexOf3)), Long.parseLong(str.substring(indexOf3 + 1))};
        return (jArr[0] << 24) + (jArr[1] << 16) + (jArr[2] << 8) + jArr[3];
    }

    public static boolean isValidLbsIP(String str) {
        String replaceFirst;
        if (str != null && !str.equals("")) {
            if (str.startsWith(DefaultWebClient.HTTPS_SCHEME)) {
                replaceFirst = str.replaceFirst(DefaultWebClient.HTTPS_SCHEME, "");
            } else if (str.startsWith(DefaultWebClient.HTTP_SCHEME)) {
                replaceFirst = str.replaceFirst(DefaultWebClient.HTTP_SCHEME, "");
            }
            if (!replaceFirst.endsWith("/lbs")) {
                return false;
            }
            String replaceFirst2 = replaceFirst.replaceFirst("/lbs", "");
            if (!replaceFirst2.equals("0.0.0.0") && !replaceFirst2.equals("255.255.255.255")) {
                return ValidIP.validate(replaceFirst2);
            }
        }
        return false;
    }

    public static void netStateChange(Context context) {
        String str = LOGTAG;
        LogUtil.d(str, "network connection change");
        NetworkInfo activeNetworkInfo = ((ConnectivityManager) context.getSystemService("connectivity")).getActiveNetworkInfo();
        if (activeNetworkInfo != null && activeNetworkInfo.isAvailable() && activeNetworkInfo.isConnected()) {
            NetworkType netWorkType = NetworkType.getNetWorkType(context);
            int intData = getIntData(context, Constants.BUCKET_NUMBER);
            LogUtil.d(str, "bucketNum =" + intData + ", netType = " + netWorkType.getNetworkType());
            for (int i = 0; i < intData; i++) {
                String data = getData(context, Constants.BUCKET_NAME + i);
                if (data != null) {
                    setBooleanData(context, data + Constants.LBS_STATUS, false);
                    setData(context, data + Constants.NET_TYPE, netWorkType.getNetworkType());
                }
            }
        }
    }

    public static String pipeBuildPostDataUrl(String str, String str2, String str3, long j, boolean z) {
        String str4;
        if (str3 != null) {
            str4 = encode(str) + "/" + encode(str2) + "?version=1.0&context=" + str3 + "&offset=" + j + "&complete=" + z;
        } else {
            str4 = encode(str) + "/" + encode(str2) + "?version=1.0&offset=" + j + "&complete=" + z;
        }
        return "/" + str4;
    }

    public static String pipeBuildQueryUrl(String str, String str2, String str3) {
        String str4;
        if (str3 != null) {
            str4 = encode(str) + "/" + encode(str2) + "?uploadContext&version=1.0&context=" + str3;
        } else {
            str4 = encode(str) + "/" + encode(str2) + "?uploadContext&version=1.0";
        }
        return "/" + str4;
    }

    public static void releaseLock(CountDownLatch countDownLatch) {
        countDownLatch.countDown();
    }

    private static String replaceWithHttps(String str) {
        return str.replaceAll(DefaultWebClient.HTTP_SCHEME, DefaultWebClient.HTTPS_SCHEME);
    }

    public static void setBooleanData(Context context, String str, boolean z) {
        SharedPreferences.Editor edit = getDefaultPreferences(context).edit();
        edit.putBoolean(str, z);
        edit.commit();
    }

    public static void setBucketName(Context context, String str) {
        SharedPreferences defaultPreferences = getDefaultPreferences(context);
        int i = defaultPreferences.getInt(Constants.BUCKET_NUMBER, 0);
        for (int i3 = 0; i3 < i; i3++) {
            if (defaultPreferences.getString(Constants.BUCKET_NAME + i3, null).equals(str)) {
                return;
            }
        }
        SharedPreferences.Editor edit = defaultPreferences.edit();
        edit.putString(Constants.BUCKET_NAME + i, str);
        edit.putInt(Constants.BUCKET_NUMBER, i + 1);
        edit.commit();
    }

    public static void setData(Context context, String str, String str2) {
        SharedPreferences.Editor edit = getDefaultPreferences(context).edit();
        edit.putString(str, str2);
        edit.commit();
    }

    public static f0.a setHeader(f0.a aVar, Map<String, String> map) {
        if (map == null) {
            return aVar;
        }
        for (String str : map.keySet()) {
            aVar.a(str, map.get(str));
        }
        return aVar;
    }

    public static HttpResult setLBSData(Context context, String str, JSONObject jSONObject) {
        try {
            String string = jSONObject.getString("lbs");
            String transformString = transformString(jSONObject.getJSONArray("upload"));
            String str2 = LOGTAG;
            LogUtil.d(str2, "lbsString: " + string);
            LogUtil.d(str2, "upload server string: " + transformString);
            if (string != null) {
                setData(context, str + Constants.LBS_KEY, string);
            }
            if (transformString != null) {
                String replaceWithHttps = replaceWithHttps(transformString);
                LogUtil.d(str2, "https servers: " + replaceWithHttps);
                setData(context, str + Constants.UPLOAD_SERVER_KEY, transformString);
                setData(context, str + Constants.HTTPS_UPLOAD_SERVER_KEY, replaceWithHttps);
                setLongData(context, str + Constants.LBS_TIME, Long.valueOf(System.currentTimeMillis()));
                setBooleanData(context, str + Constants.LBS_STATUS, true);
            }
            setBucketName(context, str);
            return new HttpResult(200, jSONObject, null);
        } catch (JSONException e) {
            LogUtil.e(LOGTAG, "get json array exception", e);
            return new HttpResult(Code.INVALID_LBS_DATA, jSONObject, null);
        }
    }

    public static void setLock(CountDownLatch countDownLatch) {
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            LogUtil.e(LOGTAG, "set lock with interrupted exception", e);
        }
    }

    public static void setLongData(Context context, String str, Long l) {
        SharedPreferences.Editor edit = getDefaultPreferences(context).edit();
        edit.putLong(str, l.longValue());
        edit.commit();
    }

    public static int transformCode(int i) {
        if (i == -5) {
            return Code.HTTP_NO_RESPONSE;
        }
        if (i == -4) {
            return Code.HTTP_EXCEPTION;
        }
        if (i != -3) {
            return i != -2 ? Code.UNKNOWN_REASON : Code.INVALID_TOKEN;
        }
        return 500;
    }

    private static String transformString(JSONArray jSONArray) {
        if (jSONArray == null || jSONArray.length() == 0) {
            return null;
        }
        String str = "";
        for (int i = 0; i < jSONArray.length(); i++) {
            try {
                str = str + jSONArray.getString(i);
                if (i != jSONArray.length() - 1) {
                    str = str + ";";
                }
            } catch (JSONException e) {
                LogUtil.e(LOGTAG, "get json string exception", e);
            }
        }
        return str;
    }
}