f.java 源代码

package w2;

import android.annotation.SuppressLint;
import android.app.ActivityManager;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Environment;
import android.text.TextUtils;
import android.util.DisplayMetrics;
import androidx.annotation.NonNull;
import com.google.gson.Gson;
import com.google.gson.JsonParseException;
import com.xuexiang.xupdate.R;
import com.xuexiang.xupdate.entity.UpdateEntity;
import com.xuexiang.xupdate.entity.UpdateError;
import java.io.File;
import java.util.List;
import t2.g;

public final class f {
    @SuppressLint({"DefaultLocale"})
    private static String a(long j6) {
        if (j6 <= 0) {
            return "";
        }
        if (j6 < 1024) {
            return String.format("%.1fB", Double.valueOf(j6));
        }
        if (j6 < 1048576) {
            return String.format("%.1fKB", Double.valueOf(j6 / 1024.0d));
        }
        if (j6 < 1073741824) {
            return String.format("%.1fMB", Double.valueOf(j6 / 1048576.0d));
        }
        return String.format("%.1fGB", Double.valueOf(j6 / 1.073741824E9d));
    }

    public static boolean b(Context context) {
        NetworkInfo activeNetworkInfo;
        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
        if (connectivityManager == null || (activeNetworkInfo = connectivityManager.getActiveNetworkInfo()) == null || !activeNetworkInfo.isConnected()) {
            return false;
        }
        return true;
    }

    public static boolean c(Context context) {
        NetworkInfo activeNetworkInfo;
        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
        if (connectivityManager == null || (activeNetworkInfo = connectivityManager.getActiveNetworkInfo()) == null || !activeNetworkInfo.isConnected() || activeNetworkInfo.getType() != 1) {
            return false;
        }
        return true;
    }

    public static int d(int i6, Context context) {
        return (int) ((i6 * k(context)) + 0.5f);
    }

    public static Bitmap e(Drawable drawable) {
        Bitmap.Config config;
        Bitmap createBitmap;
        Bitmap.Config config2;
        if (drawable instanceof BitmapDrawable) {
            BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
            if (bitmapDrawable.getBitmap() != null) {
                return bitmapDrawable.getBitmap();
            }
        }
        if (drawable.getIntrinsicWidth() > 0 && drawable.getIntrinsicHeight() > 0) {
            int intrinsicWidth = drawable.getIntrinsicWidth();
            int intrinsicHeight = drawable.getIntrinsicHeight();
            if (drawable.getOpacity() != -1) {
                config2 = Bitmap.Config.ARGB_8888;
            } else {
                config2 = Bitmap.Config.RGB_565;
            }
            createBitmap = Bitmap.createBitmap(intrinsicWidth, intrinsicHeight, config2);
        } else {
            if (drawable.getOpacity() != -1) {
                config = Bitmap.Config.ARGB_8888;
            } else {
                config = Bitmap.Config.RGB_565;
            }
            createBitmap = Bitmap.createBitmap(1, 1, config);
        }
        Canvas canvas = new Canvas(createBitmap);
        drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
        drawable.draw(canvas);
        return createBitmap;
    }

    public static <T> T f(String str, Class<T> cls) {
        try {
            return (T) new Gson().i(str, cls);
        } catch (JsonParseException e6) {
            e6.printStackTrace();
            return null;
        }
    }

    public static File g(UpdateEntity updateEntity) {
        String h6 = h(updateEntity.getDownloadUrl());
        String apkCacheDir = updateEntity.getApkCacheDir();
        StringBuilder sb = new StringBuilder();
        String str = File.separator;
        sb.append(str);
        sb.append(updateEntity.getVersionName());
        return new File(apkCacheDir.concat(sb.toString()).concat(str + h6));
    }

    @NonNull
    public static String h(String str) {
        if (TextUtils.isEmpty(str)) {
            return "temp.apk";
        }
        String substring = str.substring(str.lastIndexOf("/") + 1);
        if (!substring.endsWith(".apk")) {
            return "temp.apk";
        }
        return substring;
    }

    public static Drawable i(Context context) {
        PackageInfo o6 = o(context);
        if (o6 != null) {
            return o6.applicationInfo.loadIcon(context.getPackageManager());
        }
        return null;
    }

    public static String j(Context context) {
        PackageInfo o6 = o(context);
        if (o6 != null) {
            return o6.applicationInfo.loadLabel(context.getPackageManager()).toString();
        }
        return "";
    }

    private static float k(Context context) {
        return m(context).density;
    }

    public static String l(Context context, String str) {
        File externalCacheDir;
        if (!"mounted".equals(Environment.getExternalStorageState()) && Environment.isExternalStorageRemovable()) {
            externalCacheDir = context.getCacheDir();
        } else {
            externalCacheDir = context.getExternalCacheDir();
        }
        if (externalCacheDir == null) {
            externalCacheDir = context.getCacheDir();
        }
        return externalCacheDir.getPath() + File.separator + str;
    }

    private static DisplayMetrics m(Context context) {
        return context.getResources().getDisplayMetrics();
    }

    @NonNull
    public static String n(Context context, @NonNull UpdateEntity updateEntity) {
        String str;
        String a7 = a(updateEntity.getSize() * 1024);
        String updateContent = updateEntity.getUpdateContent();
        if (!TextUtils.isEmpty(a7)) {
            str = context.getString(R.string.xupdate_lab_new_version_size) + a7 + "\n";
        } else {
            str = "";
        }
        if (!TextUtils.isEmpty(updateContent)) {
            return str + updateContent;
        }
        return str;
    }

    private static PackageInfo o(Context context) {
        try {
            return context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
        } catch (PackageManager.NameNotFoundException e6) {
            e6.printStackTrace();
            return null;
        }
    }

    private static SharedPreferences p(Context context) {
        return context.getSharedPreferences("xupdate_prefs", 0);
    }

    public static int q(Context context) {
        PackageInfo o6 = o(context);
        if (o6 != null) {
            return o6.versionCode;
        }
        return -1;
    }

    public static boolean r(UpdateEntity updateEntity) {
        File g6 = g(updateEntity);
        if (!TextUtils.isEmpty(updateEntity.getMd5()) && g6.exists() && p2.c.h(updateEntity.getMd5(), g6)) {
            return true;
        }
        return false;
    }

    public static boolean s(Context context) {
        ActivityManager activityManager = (ActivityManager) context.getSystemService("activity");
        String packageName = context.getPackageName();
        List<ActivityManager.RunningAppProcessInfo> runningAppProcesses = activityManager.getRunningAppProcesses();
        if (runningAppProcesses == null) {
            return false;
        }
        for (ActivityManager.RunningAppProcessInfo runningAppProcessInfo : runningAppProcesses) {
            if (runningAppProcessInfo.processName.equals(packageName) && runningAppProcessInfo.importance == 100) {
                return true;
            }
        }
        return false;
    }

    public static boolean t(Context context, String str) {
        return p(context).getString("xupdate_ignore_version", "").equals(str);
    }

    public static void u(UpdateEntity updateEntity, @NonNull String str, @NonNull g gVar) throws Exception {
        if (updateEntity != null) {
            if (updateEntity.isHasUpdate()) {
                if (t(gVar.getContext(), updateEntity.getVersionName())) {
                    p2.c.n(UpdateError.ERROR.CHECK_IGNORED_VERSION);
                    return;
                } else if (TextUtils.isEmpty(updateEntity.getApkCacheDir())) {
                    p2.c.n(UpdateError.ERROR.CHECK_APK_CACHE_DIR_EMPTY);
                    return;
                } else {
                    gVar.i(updateEntity, gVar);
                    return;
                }
            }
            p2.c.n(UpdateError.ERROR.CHECK_NO_NEW_VERSION);
            return;
        }
        p2.c.o(UpdateError.ERROR.CHECK_PARSE, "json:" + str);
    }

    public static <T> T v(T t6, String str) {
        if (t6 != null) {
            return t6;
        }
        throw new NullPointerException(str);
    }

    public static void w(Context context, String str) {
        p(context).edit().putString("xupdate_ignore_version", str).apply();
    }
}