package com.squareup.leakcanary.internal;

import android.app.ActivityManager;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.ComponentName;
import android.content.Context;
import android.content.pm.PackageManager;
import android.content.pm.ServiceInfo;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Process;
import com.ijm.dataencryption.de.DataDecryptTool;
import com.squareup.leakcanary.CanaryLog;
import com.squareup.leakcanary.DefaultLeakDirectoryProvider;
import com.squareup.leakcanary.LeakDirectoryProvider;
import com.squareup.leakcanary.R;
import com.squareup.leakcanary.RefWatcher;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

/* loaded from: classes.dex */
public final class LeakCanaryInternals {
    public static final String HUAWEI = "HUAWEI";
    public static final String LENOVO = "LENOVO";
    public static final String LG = "LGE";
    public static final String MEIZU = "Meizu";
    public static final String MOTOROLA = "motorola";
    private static final String NOTIFICATION_CHANNEL_ID = "leakcanary";
    public static final String NVIDIA = "NVIDIA";
    public static final String SAMSUNG = "samsung";
    public static final String VIVO = "vivo";
    public static volatile RefWatcher installedRefWatcher;
    public static volatile Boolean isInAnalyzerProcess;
    private static volatile LeakDirectoryProvider leakDirectoryProvider;

    private LeakCanaryInternals() {
        throw new AssertionError();
    }

    public static Notification buildNotification(Context context, Notification.Builder builder) {
        builder.setSmallIcon(R.drawable.leak_canary_notification).setWhen(System.currentTimeMillis()).setOnlyAlertOnce(true);
        if (Build.VERSION.SDK_INT >= 26) {
            NotificationManager notificationManager = (NotificationManager) context.getSystemService("notification");
            if (notificationManager.getNotificationChannel(NOTIFICATION_CHANNEL_ID) == null) {
                notificationManager.createNotificationChannel(new NotificationChannel(NOTIFICATION_CHANNEL_ID, context.getString(R.string.leak_canary_notification_channel), 3));
            }
            builder.setChannelId(NOTIFICATION_CHANNEL_ID);
        }
        return Build.VERSION.SDK_INT < 16 ? builder.getNotification() : builder.build();
    }

    public static String classSimpleName(String str) {
        int lastIndexOf = str.lastIndexOf(46);
        return lastIndexOf == -1 ? str : str.substring(lastIndexOf + 1);
    }

    public static LeakDirectoryProvider getLeakDirectoryProvider(Context context) {
        LeakDirectoryProvider leakDirectoryProvider2 = leakDirectoryProvider;
        return leakDirectoryProvider2 == null ? new DefaultLeakDirectoryProvider(context) : leakDirectoryProvider2;
    }

    public static boolean isInServiceProcess(Context context, Class<? extends Service> cls) {
        PackageManager packageManager = context.getPackageManager();
        try {
            String str = packageManager.getPackageInfo(context.getPackageName(), 4).applicationInfo.processName;
            try {
                ServiceInfo serviceInfo = packageManager.getServiceInfo(new ComponentName(context, cls), DataDecryptTool.DECRYPT_DB_FILE);
                if (serviceInfo.processName.equals(str)) {
                    CanaryLog.d("Did not expect service %s to run in main process %s", cls, str);
                    return false;
                }
                int myPid = Process.myPid();
                ActivityManager.RunningAppProcessInfo runningAppProcessInfo = null;
                try {
                    List<ActivityManager.RunningAppProcessInfo> runningAppProcesses = ((ActivityManager) context.getSystemService("activity")).getRunningAppProcesses();
                    if (runningAppProcesses != null) {
                        Iterator<ActivityManager.RunningAppProcessInfo> it = runningAppProcesses.iterator();
                        while (true) {
                            if (!it.hasNext()) {
                                break;
                            }
                            ActivityManager.RunningAppProcessInfo next = it.next();
                            if (next.pid == myPid) {
                                runningAppProcessInfo = next;
                                break;
                            }
                        }
                    }
                    if (runningAppProcessInfo != null) {
                        return runningAppProcessInfo.processName.equals(serviceInfo.processName);
                    }
                    CanaryLog.d("Could not find running process for %d", Integer.valueOf(myPid));
                    return false;
                } catch (SecurityException e) {
                    CanaryLog.d("Could not get running app processes %d", e);
                    return false;
                }
            } catch (PackageManager.NameNotFoundException unused) {
            }
        } catch (Exception e2) {
            CanaryLog.d(e2, "Could not get package info for %s", context.getPackageName());
            return false;
        }
    }

    public static Executor newSingleThreadExecutor(String str) {
        return Executors.newSingleThreadExecutor(new LeakCanarySingleThreadFactory(str));
    }

    public static void setEnabledAsync(Context context, final Class<?> cls, final boolean z) {
        final Context applicationContext = context.getApplicationContext();
        AsyncTask.THREAD_POOL_EXECUTOR.execute(new Runnable() { // from class: com.squareup.leakcanary.internal.LeakCanaryInternals.1
            @Override // java.lang.Runnable
            public void run() {
                LeakCanaryInternals.setEnabledBlocking(applicationContext, cls, z);
            }
        });
    }

    public static void setEnabledBlocking(Context context, Class<?> cls, boolean z) {
        context.getPackageManager().setComponentEnabledSetting(new ComponentName(context, cls), z ? 1 : 2, 1);
    }

    public static void setLeakDirectoryProvider(LeakDirectoryProvider leakDirectoryProvider2) {
        if (leakDirectoryProvider != null) {
            throw new IllegalStateException("Cannot set the LeakDirectoryProvider after it has already been set. Try setting it before installing the RefWatcher.");
        }
        leakDirectoryProvider = leakDirectoryProvider2;
    }

    public static void showNotification(Context context, CharSequence charSequence, CharSequence charSequence2, PendingIntent pendingIntent, int i) {
        ((NotificationManager) context.getSystemService("notification")).notify(i, buildNotification(context, new Notification.Builder(context).setContentText(charSequence2).setContentTitle(charSequence).setAutoCancel(true).setContentIntent(pendingIntent)));
    }
}