ADD week 5

02-Easy5/E5/sources/androidx/core/content/ContentProviderCompat.java

@@ -0,0 +1,18 @@
+package androidx.core.content;
+
+import android.content.ContentProvider;
+import android.content.Context;
+
+/* loaded from: classes.dex */
+public final class ContentProviderCompat {
+    private ContentProviderCompat() {
+    }
+
+    public static Context requireContext(ContentProvider contentProvider) {
+        Context context = contentProvider.getContext();
+        if (context != null) {
+            return context;
+        }
+        throw new IllegalStateException("Cannot find context from the provider.");
+    }
+}

02-Easy5/E5/sources/androidx/core/content/ContentResolverCompat.java

@@ -0,0 +1,39 @@
+package androidx.core.content;
+
+import android.content.ContentResolver;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.OperationCanceledException;
+import androidx.core.os.CancellationSignal;
+
+/* loaded from: classes.dex */
+public final class ContentResolverCompat {
+    private ContentResolverCompat() {
+    }
+
+    public static Cursor query(ContentResolver contentResolver, Uri uri, String[] strArr, String str, String[] strArr2, String str2, CancellationSignal cancellationSignal) {
+        Object cancellationSignalObject;
+        if (cancellationSignal != null) {
+            try {
+                cancellationSignalObject = cancellationSignal.getCancellationSignalObject();
+            } catch (Exception e) {
+                if (e instanceof OperationCanceledException) {
+                    throw new androidx.core.os.OperationCanceledException();
+                }
+                throw e;
+            }
+        } else {
+            cancellationSignalObject = null;
+        }
+        return Api16Impl.query(contentResolver, uri, strArr, str, strArr2, str2, (android.os.CancellationSignal) cancellationSignalObject);
+    }
+
+    static class Api16Impl {
+        private Api16Impl() {
+        }
+
+        static Cursor query(ContentResolver contentResolver, Uri uri, String[] strArr, String str, String[] strArr2, String str2, android.os.CancellationSignal cancellationSignal) {
+            return contentResolver.query(uri, strArr, str, strArr2, str2, cancellationSignal);
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/ContentValuesKt.java

@@ -0,0 +1,46 @@
+package androidx.core.content;
+
+import android.content.ContentValues;
+import kotlin.Metadata;
+import kotlin.Pair;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.Typography;
+
+/* compiled from: ContentValues.kt */
+@Metadata(d1 = {"\u0000\u001c\n\u0000\n\u0002\u0018\u0002\n\u0000\n\u0002\u0010\u0011\n\u0002\u0018\u0002\n\u0002\u0010\u000e\n\u0002\u0010\u0000\n\u0002\b\u0002\u001a;\u0010\u0000\u001a\u00020\u00012.\u0010\u0002\u001a\u0018\u0012\u0014\b\u0001\u0012\u0010\u0012\u0004\u0012\u00020\u0005\u0012\u0006\u0012\u0004\u0018\u00010\u00060\u00040\u0003\"\u0010\u0012\u0004\u0012\u00020\u0005\u0012\u0006\u0012\u0004\u0018\u00010\u00060\u0004¢\u0006\u0002\u0010\u0007¨\u0006\b"}, d2 = {"contentValuesOf", "Landroid/content/ContentValues;", "pairs", "", "Lkotlin/Pair;", "", "", "([Lkotlin/Pair;)Landroid/content/ContentValues;", "core-ktx_release"}, k = 2, mv = {1, 7, 1}, xi = 48)
+/* loaded from: classes.dex */
+public final class ContentValuesKt {
+    public static final ContentValues contentValuesOf(Pair<String, ? extends Object>... pairs) {
+        Intrinsics.checkNotNullParameter(pairs, "pairs");
+        ContentValues contentValues = new ContentValues(pairs.length);
+        for (Pair<String, ? extends Object> pair : pairs) {
+            String component1 = pair.component1();
+            Object component2 = pair.component2();
+            if (component2 == null) {
+                contentValues.putNull(component1);
+            } else if (component2 instanceof String) {
+                contentValues.put(component1, (String) component2);
+            } else if (component2 instanceof Integer) {
+                contentValues.put(component1, (Integer) component2);
+            } else if (component2 instanceof Long) {
+                contentValues.put(component1, (Long) component2);
+            } else if (component2 instanceof Boolean) {
+                contentValues.put(component1, (Boolean) component2);
+            } else if (component2 instanceof Float) {
+                contentValues.put(component1, (Float) component2);
+            } else if (component2 instanceof Double) {
+                contentValues.put(component1, (Double) component2);
+            } else if (component2 instanceof byte[]) {
+                contentValues.put(component1, (byte[]) component2);
+            } else if (component2 instanceof Byte) {
+                contentValues.put(component1, (Byte) component2);
+            } else {
+                if (!(component2 instanceof Short)) {
+                    throw new IllegalArgumentException("Illegal value type " + component2.getClass().getCanonicalName() + " for key \"" + component1 + Typography.quote);
+                }
+                contentValues.put(component1, (Short) component2);
+            }
+        }
+        return contentValues;
+    }
+}

02-Easy5/E5/sources/androidx/core/content/ContextCompat.java

@@ -0,0 +1,459 @@
+package androidx.core.content;
+
+import android.accounts.AccountManager;
+import android.app.ActivityManager;
+import android.app.AlarmManager;
+import android.app.AppOpsManager;
+import android.app.DownloadManager;
+import android.app.KeyguardManager;
+import android.app.NotificationManager;
+import android.app.SearchManager;
+import android.app.UiModeManager;
+import android.app.WallpaperManager;
+import android.app.admin.DevicePolicyManager;
+import android.app.job.JobScheduler;
+import android.app.usage.UsageStatsManager;
+import android.appwidget.AppWidgetManager;
+import android.bluetooth.BluetoothManager;
+import android.content.BroadcastReceiver;
+import android.content.ClipboardManager;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.RestrictionsManager;
+import android.content.pm.LauncherApps;
+import android.content.res.ColorStateList;
+import android.graphics.drawable.Drawable;
+import android.hardware.ConsumerIrManager;
+import android.hardware.SensorManager;
+import android.hardware.camera2.CameraManager;
+import android.hardware.display.DisplayManager;
+import android.hardware.input.InputManager;
+import android.hardware.usb.UsbManager;
+import android.location.LocationManager;
+import android.media.AudioManager;
+import android.media.MediaRouter;
+import android.media.projection.MediaProjectionManager;
+import android.media.session.MediaSessionManager;
+import android.media.tv.TvInputManager;
+import android.net.ConnectivityManager;
+import android.net.nsd.NsdManager;
+import android.net.wifi.WifiManager;
+import android.net.wifi.p2p.WifiP2pManager;
+import android.nfc.NfcManager;
+import android.os.BatteryManager;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.DropBoxManager;
+import android.os.Handler;
+import android.os.PowerManager;
+import android.os.Process;
+import android.os.UserManager;
+import android.os.Vibrator;
+import android.os.storage.StorageManager;
+import android.print.PrintManager;
+import android.telecom.TelecomManager;
+import android.telephony.TelephonyManager;
+import android.text.TextUtils;
+import android.util.Log;
+import android.util.TypedValue;
+import android.view.LayoutInflater;
+import android.view.WindowManager;
+import android.view.accessibility.AccessibilityManager;
+import android.view.accessibility.CaptioningManager;
+import android.view.inputmethod.InputMethodManager;
+import android.view.textservice.TextServicesManager;
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.NotificationCompat$Style$$ExternalSyntheticApiModelOutline0;
+import androidx.core.app.NotificationManagerCompat;
+import androidx.core.content.res.ResourcesCompat;
+import androidx.core.os.BuildCompat;
+import androidx.core.os.ExecutorCompat;
+import androidx.core.util.ObjectsCompat;
+import java.io.File;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.HashMap;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes.dex */
+public class ContextCompat {
+    private static final String DYNAMIC_RECEIVER_NOT_EXPORTED_PERMISSION_SUFFIX = ".DYNAMIC_RECEIVER_NOT_EXPORTED_PERMISSION";
+    public static final int RECEIVER_EXPORTED = 2;
+    public static final int RECEIVER_NOT_EXPORTED = 4;
+    public static final int RECEIVER_VISIBLE_TO_INSTANT_APPS = 1;
+    private static final String TAG = "ContextCompat";
+    private static final Object sLock = new Object();
+    private static final Object sSync = new Object();
+    private static TypedValue sTempValue;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface RegisterReceiverFlags {
+    }
+
+    protected ContextCompat() {
+    }
+
+    public static String getAttributionTag(Context context) {
+        if (Build.VERSION.SDK_INT >= 30) {
+            return Api30Impl.getAttributionTag(context);
+        }
+        return null;
+    }
+
+    public static boolean startActivities(Context context, Intent[] intentArr) {
+        return startActivities(context, intentArr, null);
+    }
+
+    public static boolean startActivities(Context context, Intent[] intentArr, Bundle bundle) {
+        Api16Impl.startActivities(context, intentArr, bundle);
+        return true;
+    }
+
+    public static void startActivity(Context context, Intent intent, Bundle bundle) {
+        Api16Impl.startActivity(context, intent, bundle);
+    }
+
+    public static File getDataDir(Context context) {
+        if (Build.VERSION.SDK_INT >= 24) {
+            return Api24Impl.getDataDir(context);
+        }
+        String str = context.getApplicationInfo().dataDir;
+        if (str != null) {
+            return new File(str);
+        }
+        return null;
+    }
+
+    public static File[] getObbDirs(Context context) {
+        return Api19Impl.getObbDirs(context);
+    }
+
+    public static File[] getExternalFilesDirs(Context context, String str) {
+        return Api19Impl.getExternalFilesDirs(context, str);
+    }
+
+    public static File[] getExternalCacheDirs(Context context) {
+        return Api19Impl.getExternalCacheDirs(context);
+    }
+
+    public static Drawable getDrawable(Context context, int i) {
+        return Api21Impl.getDrawable(context, i);
+    }
+
+    public static ColorStateList getColorStateList(Context context, int i) {
+        return ResourcesCompat.getColorStateList(context.getResources(), i, context.getTheme());
+    }
+
+    public static int getColor(Context context, int i) {
+        if (Build.VERSION.SDK_INT >= 23) {
+            return Api23Impl.getColor(context, i);
+        }
+        return context.getResources().getColor(i);
+    }
+
+    public static int checkSelfPermission(Context context, String str) {
+        ObjectsCompat.requireNonNull(str, "permission must be non-null");
+        if (BuildCompat.isAtLeastT() || !TextUtils.equals("android.permission.POST_NOTIFICATIONS", str)) {
+            return context.checkPermission(str, Process.myPid(), Process.myUid());
+        }
+        return NotificationManagerCompat.from(context).areNotificationsEnabled() ? 0 : -1;
+    }
+
+    public static File getNoBackupFilesDir(Context context) {
+        return Api21Impl.getNoBackupFilesDir(context);
+    }
+
+    public static File getCodeCacheDir(Context context) {
+        return Api21Impl.getCodeCacheDir(context);
+    }
+
+    private static File createFilesDir(File file) {
+        synchronized (sSync) {
+            if (!file.exists()) {
+                if (file.mkdirs()) {
+                    return file;
+                }
+                Log.w(TAG, "Unable to create files subdir " + file.getPath());
+            }
+            return file;
+        }
+    }
+
+    public static Context createDeviceProtectedStorageContext(Context context) {
+        if (Build.VERSION.SDK_INT >= 24) {
+            return Api24Impl.createDeviceProtectedStorageContext(context);
+        }
+        return null;
+    }
+
+    public static boolean isDeviceProtectedStorage(Context context) {
+        if (Build.VERSION.SDK_INT >= 24) {
+            return Api24Impl.isDeviceProtectedStorage(context);
+        }
+        return false;
+    }
+
+    public static Executor getMainExecutor(Context context) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.getMainExecutor(context);
+        }
+        return ExecutorCompat.create(new Handler(context.getMainLooper()));
+    }
+
+    public static void startForegroundService(Context context, Intent intent) {
+        if (Build.VERSION.SDK_INT >= 26) {
+            Api26Impl.startForegroundService(context, intent);
+        } else {
+            context.startService(intent);
+        }
+    }
+
+    public static <T> T getSystemService(Context context, Class<T> cls) {
+        if (Build.VERSION.SDK_INT >= 23) {
+            return (T) Api23Impl.getSystemService(context, cls);
+        }
+        String systemServiceName = getSystemServiceName(context, cls);
+        if (systemServiceName != null) {
+            return (T) context.getSystemService(systemServiceName);
+        }
+        return null;
+    }
+
+    public static Intent registerReceiver(Context context, BroadcastReceiver broadcastReceiver, IntentFilter intentFilter, int i) {
+        return registerReceiver(context, broadcastReceiver, intentFilter, null, null, i);
+    }
+
+    public static Intent registerReceiver(Context context, BroadcastReceiver broadcastReceiver, IntentFilter intentFilter, String str, Handler handler, int i) {
+        int i2 = i & 1;
+        if (i2 != 0 && (i & 4) != 0) {
+            throw new IllegalArgumentException("Cannot specify both RECEIVER_VISIBLE_TO_INSTANT_APPS and RECEIVER_NOT_EXPORTED");
+        }
+        if (i2 != 0) {
+            i |= 2;
+        }
+        int i3 = i;
+        int i4 = i3 & 2;
+        if (i4 == 0 && (i3 & 4) == 0) {
+            throw new IllegalArgumentException("One of either RECEIVER_EXPORTED or RECEIVER_NOT_EXPORTED is required");
+        }
+        if (i4 != 0 && (i3 & 4) != 0) {
+            throw new IllegalArgumentException("Cannot specify both RECEIVER_EXPORTED and RECEIVER_NOT_EXPORTED");
+        }
+        if (BuildCompat.isAtLeastT()) {
+            return Api33Impl.registerReceiver(context, broadcastReceiver, intentFilter, str, handler, i3);
+        }
+        if (Build.VERSION.SDK_INT >= 26) {
+            return Api26Impl.registerReceiver(context, broadcastReceiver, intentFilter, str, handler, i3);
+        }
+        if ((i3 & 4) != 0 && str == null) {
+            return context.registerReceiver(broadcastReceiver, intentFilter, obtainAndCheckReceiverPermission(context), handler);
+        }
+        return context.registerReceiver(broadcastReceiver, intentFilter, str, handler);
+    }
+
+    public static String getSystemServiceName(Context context, Class<?> cls) {
+        if (Build.VERSION.SDK_INT >= 23) {
+            return Api23Impl.getSystemServiceName(context, cls);
+        }
+        return LegacyServiceMapHolder.SERVICES.get(cls);
+    }
+
+    static String obtainAndCheckReceiverPermission(Context context) {
+        String str = context.getPackageName() + DYNAMIC_RECEIVER_NOT_EXPORTED_PERMISSION_SUFFIX;
+        if (PermissionChecker.checkSelfPermission(context, str) == 0) {
+            return str;
+        }
+        throw new RuntimeException("Permission " + str + " is required by your application to receive broadcasts, please add it to your manifest");
+    }
+
+    private static final class LegacyServiceMapHolder {
+        static final HashMap<Class<?>, String> SERVICES;
+
+        private LegacyServiceMapHolder() {
+        }
+
+        static {
+            HashMap<Class<?>, String> hashMap = new HashMap<>();
+            SERVICES = hashMap;
+            if (Build.VERSION.SDK_INT >= 22) {
+                hashMap.put(NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$2(), "telephony_subscription_service");
+                hashMap.put(UsageStatsManager.class, "usagestats");
+            }
+            hashMap.put(AppWidgetManager.class, "appwidget");
+            hashMap.put(BatteryManager.class, "batterymanager");
+            hashMap.put(CameraManager.class, "camera");
+            hashMap.put(JobScheduler.class, "jobscheduler");
+            hashMap.put(LauncherApps.class, "launcherapps");
+            hashMap.put(MediaProjectionManager.class, "media_projection");
+            hashMap.put(MediaSessionManager.class, "media_session");
+            hashMap.put(RestrictionsManager.class, "restrictions");
+            hashMap.put(TelecomManager.class, "telecom");
+            hashMap.put(TvInputManager.class, "tv_input");
+            hashMap.put(AppOpsManager.class, "appops");
+            hashMap.put(CaptioningManager.class, "captioning");
+            hashMap.put(ConsumerIrManager.class, "consumer_ir");
+            hashMap.put(PrintManager.class, "print");
+            hashMap.put(BluetoothManager.class, "bluetooth");
+            hashMap.put(DisplayManager.class, "display");
+            hashMap.put(UserManager.class, "user");
+            hashMap.put(InputManager.class, "input");
+            hashMap.put(MediaRouter.class, "media_router");
+            hashMap.put(NsdManager.class, "servicediscovery");
+            hashMap.put(AccessibilityManager.class, "accessibility");
+            hashMap.put(AccountManager.class, "account");
+            hashMap.put(ActivityManager.class, "activity");
+            hashMap.put(AlarmManager.class, NotificationCompat.CATEGORY_ALARM);
+            hashMap.put(AudioManager.class, "audio");
+            hashMap.put(ClipboardManager.class, "clipboard");
+            hashMap.put(ConnectivityManager.class, "connectivity");
+            hashMap.put(DevicePolicyManager.class, "device_policy");
+            hashMap.put(DownloadManager.class, "download");
+            hashMap.put(DropBoxManager.class, "dropbox");
+            hashMap.put(InputMethodManager.class, "input_method");
+            hashMap.put(KeyguardManager.class, "keyguard");
+            hashMap.put(LayoutInflater.class, "layout_inflater");
+            hashMap.put(LocationManager.class, "location");
+            hashMap.put(NfcManager.class, "nfc");
+            hashMap.put(NotificationManager.class, "notification");
+            hashMap.put(PowerManager.class, "power");
+            hashMap.put(SearchManager.class, "search");
+            hashMap.put(SensorManager.class, "sensor");
+            hashMap.put(StorageManager.class, "storage");
+            hashMap.put(TelephonyManager.class, "phone");
+            hashMap.put(TextServicesManager.class, "textservices");
+            hashMap.put(UiModeManager.class, "uimode");
+            hashMap.put(UsbManager.class, "usb");
+            hashMap.put(Vibrator.class, "vibrator");
+            hashMap.put(WallpaperManager.class, "wallpaper");
+            hashMap.put(WifiP2pManager.class, "wifip2p");
+            hashMap.put(WifiManager.class, "wifi");
+            hashMap.put(WindowManager.class, "window");
+        }
+    }
+
+    static class Api16Impl {
+        private Api16Impl() {
+        }
+
+        static void startActivities(Context context, Intent[] intentArr, Bundle bundle) {
+            context.startActivities(intentArr, bundle);
+        }
+
+        static void startActivity(Context context, Intent intent, Bundle bundle) {
+            context.startActivity(intent, bundle);
+        }
+    }
+
+    static class Api19Impl {
+        private Api19Impl() {
+        }
+
+        static File[] getExternalCacheDirs(Context context) {
+            return context.getExternalCacheDirs();
+        }
+
+        static File[] getExternalFilesDirs(Context context, String str) {
+            return context.getExternalFilesDirs(str);
+        }
+
+        static File[] getObbDirs(Context context) {
+            return context.getObbDirs();
+        }
+    }
+
+    static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        static Drawable getDrawable(Context context, int i) {
+            return context.getDrawable(i);
+        }
+
+        static File getNoBackupFilesDir(Context context) {
+            return context.getNoBackupFilesDir();
+        }
+
+        static File getCodeCacheDir(Context context) {
+            return context.getCodeCacheDir();
+        }
+    }
+
+    static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        static int getColor(Context context, int i) {
+            return context.getColor(i);
+        }
+
+        static <T> T getSystemService(Context context, Class<T> cls) {
+            return (T) context.getSystemService(cls);
+        }
+
+        static String getSystemServiceName(Context context, Class<?> cls) {
+            return context.getSystemServiceName(cls);
+        }
+    }
+
+    static class Api24Impl {
+        private Api24Impl() {
+        }
+
+        static File getDataDir(Context context) {
+            return context.getDataDir();
+        }
+
+        static Context createDeviceProtectedStorageContext(Context context) {
+            return context.createDeviceProtectedStorageContext();
+        }
+
+        static boolean isDeviceProtectedStorage(Context context) {
+            return context.isDeviceProtectedStorage();
+        }
+    }
+
+    static class Api26Impl {
+        private Api26Impl() {
+        }
+
+        static Intent registerReceiver(Context context, BroadcastReceiver broadcastReceiver, IntentFilter intentFilter, String str, Handler handler, int i) {
+            if ((i & 4) != 0 && str == null) {
+                return context.registerReceiver(broadcastReceiver, intentFilter, ContextCompat.obtainAndCheckReceiverPermission(context), handler);
+            }
+            return context.registerReceiver(broadcastReceiver, intentFilter, str, handler, i & 1);
+        }
+
+        static ComponentName startForegroundService(Context context, Intent intent) {
+            return context.startForegroundService(intent);
+        }
+    }
+
+    static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        static Executor getMainExecutor(Context context) {
+            return context.getMainExecutor();
+        }
+    }
+
+    static class Api30Impl {
+        private Api30Impl() {
+        }
+
+        static String getAttributionTag(Context context) {
+            return context.getAttributionTag();
+        }
+    }
+
+    static class Api33Impl {
+        private Api33Impl() {
+        }
+
+        static Intent registerReceiver(Context context, BroadcastReceiver broadcastReceiver, IntentFilter intentFilter, String str, Handler handler, int i) {
+            return context.registerReceiver(broadcastReceiver, intentFilter, str, handler, i);
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/ContextKt.java

@@ -0,0 +1,59 @@
+package androidx.core.content;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.util.AttributeSet;
+import kotlin.Metadata;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* compiled from: Context.kt */
+@Metadata(d1 = {"\u0000:\n\u0002\b\u0002\n\u0002\u0010\u0000\n\u0002\u0018\u0002\n\u0002\b\u0002\n\u0002\u0010\u0002\n\u0000\n\u0002\u0018\u0002\n\u0000\n\u0002\u0010\u0015\n\u0000\n\u0002\u0010\b\n\u0002\b\u0002\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\b\u0002\u001a \u0010\u0000\u001a\u0004\u0018\u0001H\u0001\"\n\b\u0000\u0010\u0001\u0018\u0001*\u00020\u0002*\u00020\u0003H\u0086\b¢\u0006\u0002\u0010\u0004\u001aQ\u0010\u0005\u001a\u00020\u0006*\u00020\u00032\n\b\u0002\u0010\u0007\u001a\u0004\u0018\u00010\b2\u0006\u0010\t\u001a\u00020\n2\b\b\u0003\u0010\u000b\u001a\u00020\f2\b\b\u0003\u0010\r\u001a\u00020\f2\u0017\u0010\u000e\u001a\u0013\u0012\u0004\u0012\u00020\u0010\u0012\u0004\u0012\u00020\u00060\u000f¢\u0006\u0002\b\u0011H\u0086\bø\u0001\u0000\u001a;\u0010\u0005\u001a\u00020\u0006*\u00020\u00032\b\b\u0001\u0010\u0012\u001a\u00020\f2\u0006\u0010\t\u001a\u00020\n2\u0017\u0010\u000e\u001a\u0013\u0012\u0004\u0012\u00020\u0010\u0012\u0004\u0012\u00020\u00060\u000f¢\u0006\u0002\b\u0011H\u0086\bø\u0001\u0000\u0082\u0002\u0007\n\u0005\b\u009920\u0001¨\u0006\u0013"}, d2 = {"getSystemService", "T", "", "Landroid/content/Context;", "(Landroid/content/Context;)Ljava/lang/Object;", "withStyledAttributes", "", "set", "Landroid/util/AttributeSet;", "attrs", "", "defStyleAttr", "", "defStyleRes", "block", "Lkotlin/Function1;", "Landroid/content/res/TypedArray;", "Lkotlin/ExtensionFunctionType;", "resourceId", "core-ktx_release"}, k = 2, mv = {1, 7, 1}, xi = 48)
+/* loaded from: classes.dex */
+public final class ContextKt {
+    public static final /* synthetic */ <T> T getSystemService(Context context) {
+        Intrinsics.checkNotNullParameter(context, "<this>");
+        Intrinsics.reifiedOperationMarker(4, "T");
+        return (T) ContextCompat.getSystemService(context, Object.class);
+    }
+
+    public static /* synthetic */ void withStyledAttributes$default(Context context, AttributeSet attributeSet, int[] attrs, int i, int i2, Function1 block, int i3, Object obj) {
+        if ((i3 & 1) != 0) {
+            attributeSet = null;
+        }
+        if ((i3 & 4) != 0) {
+            i = 0;
+        }
+        if ((i3 & 8) != 0) {
+            i2 = 0;
+        }
+        Intrinsics.checkNotNullParameter(context, "<this>");
+        Intrinsics.checkNotNullParameter(attrs, "attrs");
+        Intrinsics.checkNotNullParameter(block, "block");
+        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, attrs, i, i2);
+        Intrinsics.checkNotNullExpressionValue(obtainStyledAttributes, "obtainStyledAttributes(s…efStyleAttr, defStyleRes)");
+        block.invoke(obtainStyledAttributes);
+        obtainStyledAttributes.recycle();
+    }
+
+    public static final void withStyledAttributes(Context context, AttributeSet attributeSet, int[] attrs, int i, int i2, Function1<? super TypedArray, Unit> block) {
+        Intrinsics.checkNotNullParameter(context, "<this>");
+        Intrinsics.checkNotNullParameter(attrs, "attrs");
+        Intrinsics.checkNotNullParameter(block, "block");
+        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, attrs, i, i2);
+        Intrinsics.checkNotNullExpressionValue(obtainStyledAttributes, "obtainStyledAttributes(s…efStyleAttr, defStyleRes)");
+        block.invoke(obtainStyledAttributes);
+        obtainStyledAttributes.recycle();
+    }
+
+    public static final void withStyledAttributes(Context context, int i, int[] attrs, Function1<? super TypedArray, Unit> block) {
+        Intrinsics.checkNotNullParameter(context, "<this>");
+        Intrinsics.checkNotNullParameter(attrs, "attrs");
+        Intrinsics.checkNotNullParameter(block, "block");
+        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(i, attrs);
+        Intrinsics.checkNotNullExpressionValue(obtainStyledAttributes, "obtainStyledAttributes(resourceId, attrs)");
+        block.invoke(obtainStyledAttributes);
+        obtainStyledAttributes.recycle();
+    }
+}

02-Easy5/E5/sources/androidx/core/content/FileProvider.java

@@ -0,0 +1,344 @@
+package androidx.core.content;
+
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.pm.ProviderInfo;
+import android.content.res.XmlResourceParser;
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Environment;
+import android.os.ParcelFileDescriptor;
+import android.text.TextUtils;
+import android.webkit.MimeTypeMap;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import org.xmlpull.v1.XmlPullParserException;
+
+/* loaded from: classes.dex */
+public class FileProvider extends ContentProvider {
+    private static final String ATTR_NAME = "name";
+    private static final String ATTR_PATH = "path";
+    private static final String DISPLAYNAME_FIELD = "displayName";
+    private static final String META_DATA_FILE_PROVIDER_PATHS = "android.support.FILE_PROVIDER_PATHS";
+    private static final String TAG_CACHE_PATH = "cache-path";
+    private static final String TAG_EXTERNAL = "external-path";
+    private static final String TAG_EXTERNAL_CACHE = "external-cache-path";
+    private static final String TAG_EXTERNAL_FILES = "external-files-path";
+    private static final String TAG_EXTERNAL_MEDIA = "external-media-path";
+    private static final String TAG_FILES_PATH = "files-path";
+    private static final String TAG_ROOT_PATH = "root-path";
+    private int mResourceId;
+    private PathStrategy mStrategy;
+    private static final String[] COLUMNS = {"_display_name", "_size"};
+    private static final File DEVICE_ROOT = new File("/");
+    private static final HashMap<String, PathStrategy> sCache = new HashMap<>();
+
+    interface PathStrategy {
+        File getFileForUri(Uri uri);
+
+        Uri getUriForFile(File file);
+    }
+
+    @Override // android.content.ContentProvider
+    public boolean onCreate() {
+        return true;
+    }
+
+    public FileProvider() {
+        this.mResourceId = 0;
+    }
+
+    protected FileProvider(int i) {
+        this.mResourceId = i;
+    }
+
+    @Override // android.content.ContentProvider
+    public void attachInfo(Context context, ProviderInfo providerInfo) {
+        super.attachInfo(context, providerInfo);
+        if (providerInfo.exported) {
+            throw new SecurityException("Provider must not be exported");
+        }
+        if (!providerInfo.grantUriPermissions) {
+            throw new SecurityException("Provider must grant uri permissions");
+        }
+        String str = providerInfo.authority.split(";")[0];
+        HashMap<String, PathStrategy> hashMap = sCache;
+        synchronized (hashMap) {
+            hashMap.remove(str);
+        }
+        this.mStrategy = getPathStrategy(context, str, this.mResourceId);
+    }
+
+    public static Uri getUriForFile(Context context, String str, File file) {
+        return getPathStrategy(context, str, 0).getUriForFile(file);
+    }
+
+    public static Uri getUriForFile(Context context, String str, File file, String str2) {
+        return getUriForFile(context, str, file).buildUpon().appendQueryParameter(DISPLAYNAME_FIELD, str2).build();
+    }
+
+    @Override // android.content.ContentProvider
+    public Cursor query(Uri uri, String[] strArr, String str, String[] strArr2, String str2) {
+        int i;
+        File fileForUri = this.mStrategy.getFileForUri(uri);
+        String queryParameter = uri.getQueryParameter(DISPLAYNAME_FIELD);
+        if (strArr == null) {
+            strArr = COLUMNS;
+        }
+        String[] strArr3 = new String[strArr.length];
+        Object[] objArr = new Object[strArr.length];
+        int i2 = 0;
+        for (String str3 : strArr) {
+            if ("_display_name".equals(str3)) {
+                strArr3[i2] = "_display_name";
+                i = i2 + 1;
+                objArr[i2] = queryParameter == null ? fileForUri.getName() : queryParameter;
+            } else if ("_size".equals(str3)) {
+                strArr3[i2] = "_size";
+                i = i2 + 1;
+                objArr[i2] = Long.valueOf(fileForUri.length());
+            }
+            i2 = i;
+        }
+        String[] copyOf = copyOf(strArr3, i2);
+        Object[] copyOf2 = copyOf(objArr, i2);
+        MatrixCursor matrixCursor = new MatrixCursor(copyOf, 1);
+        matrixCursor.addRow(copyOf2);
+        return matrixCursor;
+    }
+
+    @Override // android.content.ContentProvider
+    public String getType(Uri uri) {
+        File fileForUri = this.mStrategy.getFileForUri(uri);
+        int lastIndexOf = fileForUri.getName().lastIndexOf(46);
+        if (lastIndexOf < 0) {
+            return "application/octet-stream";
+        }
+        String mimeTypeFromExtension = MimeTypeMap.getSingleton().getMimeTypeFromExtension(fileForUri.getName().substring(lastIndexOf + 1));
+        return mimeTypeFromExtension != null ? mimeTypeFromExtension : "application/octet-stream";
+    }
+
+    @Override // android.content.ContentProvider
+    public Uri insert(Uri uri, ContentValues contentValues) {
+        throw new UnsupportedOperationException("No external inserts");
+    }
+
+    @Override // android.content.ContentProvider
+    public int update(Uri uri, ContentValues contentValues, String str, String[] strArr) {
+        throw new UnsupportedOperationException("No external updates");
+    }
+
+    @Override // android.content.ContentProvider
+    public int delete(Uri uri, String str, String[] strArr) {
+        return this.mStrategy.getFileForUri(uri).delete() ? 1 : 0;
+    }
+
+    @Override // android.content.ContentProvider
+    public ParcelFileDescriptor openFile(Uri uri, String str) throws FileNotFoundException {
+        return ParcelFileDescriptor.open(this.mStrategy.getFileForUri(uri), modeToMode(str));
+    }
+
+    private static PathStrategy getPathStrategy(Context context, String str, int i) {
+        PathStrategy pathStrategy;
+        HashMap<String, PathStrategy> hashMap = sCache;
+        synchronized (hashMap) {
+            pathStrategy = hashMap.get(str);
+            if (pathStrategy == null) {
+                try {
+                    try {
+                        pathStrategy = parsePathStrategy(context, str, i);
+                        hashMap.put(str, pathStrategy);
+                    } catch (XmlPullParserException e) {
+                        throw new IllegalArgumentException("Failed to parse android.support.FILE_PROVIDER_PATHS meta-data", e);
+                    }
+                } catch (IOException e2) {
+                    throw new IllegalArgumentException("Failed to parse android.support.FILE_PROVIDER_PATHS meta-data", e2);
+                }
+            }
+        }
+        return pathStrategy;
+    }
+
+    static XmlResourceParser getFileProviderPathsMetaData(Context context, String str, ProviderInfo providerInfo, int i) {
+        if (providerInfo == null) {
+            throw new IllegalArgumentException("Couldn't find meta-data for provider with authority " + str);
+        }
+        if (providerInfo.metaData == null && i != 0) {
+            providerInfo.metaData = new Bundle(1);
+            providerInfo.metaData.putInt(META_DATA_FILE_PROVIDER_PATHS, i);
+        }
+        XmlResourceParser loadXmlMetaData = providerInfo.loadXmlMetaData(context.getPackageManager(), META_DATA_FILE_PROVIDER_PATHS);
+        if (loadXmlMetaData != null) {
+            return loadXmlMetaData;
+        }
+        throw new IllegalArgumentException("Missing android.support.FILE_PROVIDER_PATHS meta-data");
+    }
+
+    private static PathStrategy parsePathStrategy(Context context, String str, int i) throws IOException, XmlPullParserException {
+        SimplePathStrategy simplePathStrategy = new SimplePathStrategy(str);
+        XmlResourceParser fileProviderPathsMetaData = getFileProviderPathsMetaData(context, str, context.getPackageManager().resolveContentProvider(str, 128), i);
+        while (true) {
+            int next = fileProviderPathsMetaData.next();
+            if (next == 1) {
+                return simplePathStrategy;
+            }
+            if (next == 2) {
+                String name = fileProviderPathsMetaData.getName();
+                File file = null;
+                String attributeValue = fileProviderPathsMetaData.getAttributeValue(null, ATTR_NAME);
+                String attributeValue2 = fileProviderPathsMetaData.getAttributeValue(null, ATTR_PATH);
+                if (TAG_ROOT_PATH.equals(name)) {
+                    file = DEVICE_ROOT;
+                } else if (TAG_FILES_PATH.equals(name)) {
+                    file = context.getFilesDir();
+                } else if (TAG_CACHE_PATH.equals(name)) {
+                    file = context.getCacheDir();
+                } else if (TAG_EXTERNAL.equals(name)) {
+                    file = Environment.getExternalStorageDirectory();
+                } else if (TAG_EXTERNAL_FILES.equals(name)) {
+                    File[] externalFilesDirs = ContextCompat.getExternalFilesDirs(context, null);
+                    if (externalFilesDirs.length > 0) {
+                        file = externalFilesDirs[0];
+                    }
+                } else if (TAG_EXTERNAL_CACHE.equals(name)) {
+                    File[] externalCacheDirs = ContextCompat.getExternalCacheDirs(context);
+                    if (externalCacheDirs.length > 0) {
+                        file = externalCacheDirs[0];
+                    }
+                } else if (TAG_EXTERNAL_MEDIA.equals(name)) {
+                    File[] externalMediaDirs = Api21Impl.getExternalMediaDirs(context);
+                    if (externalMediaDirs.length > 0) {
+                        file = externalMediaDirs[0];
+                    }
+                }
+                if (file != null) {
+                    simplePathStrategy.addRoot(attributeValue, buildPath(file, attributeValue2));
+                }
+            }
+        }
+    }
+
+    static class SimplePathStrategy implements PathStrategy {
+        private final String mAuthority;
+        private final HashMap<String, File> mRoots = new HashMap<>();
+
+        SimplePathStrategy(String str) {
+            this.mAuthority = str;
+        }
+
+        void addRoot(String str, File file) {
+            if (TextUtils.isEmpty(str)) {
+                throw new IllegalArgumentException("Name must not be empty");
+            }
+            try {
+                this.mRoots.put(str, file.getCanonicalFile());
+            } catch (IOException e) {
+                throw new IllegalArgumentException("Failed to resolve canonical path for " + file, e);
+            }
+        }
+
+        @Override // androidx.core.content.FileProvider.PathStrategy
+        public Uri getUriForFile(File file) {
+            String substring;
+            try {
+                String canonicalPath = file.getCanonicalPath();
+                Map.Entry<String, File> entry = null;
+                for (Map.Entry<String, File> entry2 : this.mRoots.entrySet()) {
+                    String path = entry2.getValue().getPath();
+                    if (canonicalPath.startsWith(path) && (entry == null || path.length() > entry.getValue().getPath().length())) {
+                        entry = entry2;
+                    }
+                }
+                if (entry == null) {
+                    throw new IllegalArgumentException("Failed to find configured root that contains " + canonicalPath);
+                }
+                String path2 = entry.getValue().getPath();
+                if (path2.endsWith("/")) {
+                    substring = canonicalPath.substring(path2.length());
+                } else {
+                    substring = canonicalPath.substring(path2.length() + 1);
+                }
+                return new Uri.Builder().scheme("content").authority(this.mAuthority).encodedPath(Uri.encode(entry.getKey()) + '/' + Uri.encode(substring, "/")).build();
+            } catch (IOException unused) {
+                throw new IllegalArgumentException("Failed to resolve canonical path for " + file);
+            }
+        }
+
+        @Override // androidx.core.content.FileProvider.PathStrategy
+        public File getFileForUri(Uri uri) {
+            String encodedPath = uri.getEncodedPath();
+            int indexOf = encodedPath.indexOf(47, 1);
+            String decode = Uri.decode(encodedPath.substring(1, indexOf));
+            String decode2 = Uri.decode(encodedPath.substring(indexOf + 1));
+            File file = this.mRoots.get(decode);
+            if (file == null) {
+                throw new IllegalArgumentException("Unable to find configured root for " + uri);
+            }
+            File file2 = new File(file, decode2);
+            try {
+                File canonicalFile = file2.getCanonicalFile();
+                if (canonicalFile.getPath().startsWith(file.getPath())) {
+                    return canonicalFile;
+                }
+                throw new SecurityException("Resolved path jumped beyond configured root");
+            } catch (IOException unused) {
+                throw new IllegalArgumentException("Failed to resolve canonical path for " + file2);
+            }
+        }
+    }
+
+    private static int modeToMode(String str) {
+        if ("r".equals(str)) {
+            return 268435456;
+        }
+        if ("w".equals(str) || "wt".equals(str)) {
+            return 738197504;
+        }
+        if ("wa".equals(str)) {
+            return 704643072;
+        }
+        if ("rw".equals(str)) {
+            return 939524096;
+        }
+        if ("rwt".equals(str)) {
+            return 1006632960;
+        }
+        throw new IllegalArgumentException("Invalid mode: " + str);
+    }
+
+    private static File buildPath(File file, String... strArr) {
+        for (String str : strArr) {
+            if (str != null) {
+                file = new File(file, str);
+            }
+        }
+        return file;
+    }
+
+    private static String[] copyOf(String[] strArr, int i) {
+        String[] strArr2 = new String[i];
+        System.arraycopy(strArr, 0, strArr2, 0, i);
+        return strArr2;
+    }
+
+    private static Object[] copyOf(Object[] objArr, int i) {
+        Object[] objArr2 = new Object[i];
+        System.arraycopy(objArr, 0, objArr2, 0, i);
+        return objArr2;
+    }
+
+    static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        static File[] getExternalMediaDirs(Context context) {
+            return context.getExternalMediaDirs();
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/IntentCompat.java

@@ -0,0 +1,43 @@
+package androidx.core.content;
+
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import androidx.core.util.Preconditions;
+
+/* loaded from: classes.dex */
+public final class IntentCompat {
+    public static final String ACTION_CREATE_REMINDER = "android.intent.action.CREATE_REMINDER";
+    public static final String CATEGORY_LEANBACK_LAUNCHER = "android.intent.category.LEANBACK_LAUNCHER";
+    public static final String EXTRA_HTML_TEXT = "android.intent.extra.HTML_TEXT";
+    public static final String EXTRA_START_PLAYBACK = "android.intent.extra.START_PLAYBACK";
+    public static final String EXTRA_TIME = "android.intent.extra.TIME";
+
+    private IntentCompat() {
+    }
+
+    public static Intent makeMainSelectorActivity(String str, String str2) {
+        return Api15Impl.makeMainSelectorActivity(str, str2);
+    }
+
+    public static Intent createManageUnusedAppRestrictionsIntent(Context context, String str) {
+        if (!PackageManagerCompat.areUnusedAppRestrictionsAvailable(context.getPackageManager())) {
+            throw new UnsupportedOperationException("Unused App Restriction features are not available on this device");
+        }
+        if (Build.VERSION.SDK_INT >= 31) {
+            return new Intent("android.settings.APPLICATION_DETAILS_SETTINGS").setData(Uri.fromParts("package", str, null));
+        }
+        Intent data = new Intent(PackageManagerCompat.ACTION_PERMISSION_REVOCATION_SETTINGS).setData(Uri.fromParts("package", str, null));
+        return Build.VERSION.SDK_INT >= 30 ? data : data.setPackage((String) Preconditions.checkNotNull(PackageManagerCompat.getPermissionRevocationVerifierApp(context.getPackageManager())));
+    }
+
+    static class Api15Impl {
+        private Api15Impl() {
+        }
+
+        static Intent makeMainSelectorActivity(String str, String str2) {
+            return Intent.makeMainSelectorActivity(str, str2);
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/IntentSanitizer$Builder$$ExternalSyntheticLambda2.java

@@ -0,0 +1,29 @@
+package androidx.core.content;
+
+import androidx.core.util.Predicate;
+
+/* compiled from: D8$$SyntheticClass */
+/* loaded from: classes.dex */
+public final /* synthetic */ class IntentSanitizer$Builder$$ExternalSyntheticLambda2 implements Predicate {
+    public final /* synthetic */ String f$0;
+
+    @Override // androidx.core.util.Predicate
+    public /* synthetic */ Predicate and(Predicate predicate) {
+        return Predicate.CC.$default$and(this, predicate);
+    }
+
+    @Override // androidx.core.util.Predicate
+    public /* synthetic */ Predicate negate() {
+        return Predicate.CC.$default$negate(this);
+    }
+
+    @Override // androidx.core.util.Predicate
+    public /* synthetic */ Predicate or(Predicate predicate) {
+        return Predicate.CC.$default$or(this, predicate);
+    }
+
+    @Override // androidx.core.util.Predicate
+    public final boolean test(Object obj) {
+        return this.f$0.equals((String) obj);
+    }
+}

02-Easy5/E5/sources/androidx/core/content/IntentSanitizer.java

@@ -0,0 +1,986 @@
+package androidx.core.content;
+
+import android.content.ClipData;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.view.textclassifier.TextLinks;
+import androidx.core.content.IntentSanitizer;
+import androidx.core.util.Consumer;
+import androidx.core.util.Preconditions;
+import androidx.core.util.Predicate;
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+public class IntentSanitizer {
+    private static final String TAG = "IntentSanitizer";
+    private boolean mAllowAnyComponent;
+    private boolean mAllowClipDataText;
+    private boolean mAllowIdentifier;
+    private boolean mAllowSelector;
+    private boolean mAllowSourceBounds;
+    private Predicate<String> mAllowedActions;
+    private Predicate<String> mAllowedCategories;
+    private Predicate<ClipData> mAllowedClipData;
+    private Predicate<Uri> mAllowedClipDataUri;
+    private Predicate<ComponentName> mAllowedComponents;
+    private Predicate<Uri> mAllowedData;
+    private Map<String, Predicate<Object>> mAllowedExtras;
+    private int mAllowedFlags;
+    private Predicate<String> mAllowedPackages;
+    private Predicate<String> mAllowedTypes;
+
+    static /* synthetic */ void lambda$sanitizeByFiltering$0(String str) {
+    }
+
+    private IntentSanitizer() {
+    }
+
+    public Intent sanitizeByFiltering(Intent intent) {
+        return sanitize(intent, new Consumer() { // from class: androidx.core.content.IntentSanitizer$$ExternalSyntheticLambda0
+            @Override // androidx.core.util.Consumer
+            public final void accept(Object obj) {
+                IntentSanitizer.lambda$sanitizeByFiltering$0((String) obj);
+            }
+        });
+    }
+
+    public Intent sanitizeByThrowing(Intent intent) {
+        return sanitize(intent, new Consumer() { // from class: androidx.core.content.IntentSanitizer$$ExternalSyntheticLambda1
+            @Override // androidx.core.util.Consumer
+            public final void accept(Object obj) {
+                IntentSanitizer.lambda$sanitizeByThrowing$1((String) obj);
+            }
+        });
+    }
+
+    static /* synthetic */ void lambda$sanitizeByThrowing$1(String str) {
+        throw new SecurityException(str);
+    }
+
+    public Intent sanitize(Intent intent, Consumer<String> consumer) {
+        Intent intent2 = new Intent();
+        ComponentName component = intent.getComponent();
+        if ((this.mAllowAnyComponent && component == null) || this.mAllowedComponents.test(component)) {
+            intent2.setComponent(component);
+        } else {
+            consumer.accept("Component is not allowed: " + component);
+            intent2.setComponent(new ComponentName("android", "java.lang.Void"));
+        }
+        String str = intent.getPackage();
+        if (str == null || this.mAllowedPackages.test(str)) {
+            intent2.setPackage(str);
+        } else {
+            consumer.accept("Package is not allowed: " + str);
+        }
+        int flags = this.mAllowedFlags | intent.getFlags();
+        int i = this.mAllowedFlags;
+        if (flags == i) {
+            intent2.setFlags(intent.getFlags());
+        } else {
+            intent2.setFlags(intent.getFlags() & i);
+            consumer.accept("The intent contains flags that are not allowed: 0x" + Integer.toHexString(intent.getFlags() & (~this.mAllowedFlags)));
+        }
+        String action = intent.getAction();
+        if (action == null || this.mAllowedActions.test(action)) {
+            intent2.setAction(action);
+        } else {
+            consumer.accept("Action is not allowed: " + action);
+        }
+        Uri data = intent.getData();
+        if (data == null || this.mAllowedData.test(data)) {
+            intent2.setData(data);
+        } else {
+            consumer.accept("Data is not allowed: " + data);
+        }
+        String type = intent.getType();
+        if (type == null || this.mAllowedTypes.test(type)) {
+            intent2.setDataAndType(intent2.getData(), type);
+        } else {
+            consumer.accept("Type is not allowed: " + type);
+        }
+        Set<String> categories = intent.getCategories();
+        if (categories != null) {
+            for (String str2 : categories) {
+                if (this.mAllowedCategories.test(str2)) {
+                    intent2.addCategory(str2);
+                } else {
+                    consumer.accept("Category is not allowed: " + str2);
+                }
+            }
+        }
+        Bundle extras = intent.getExtras();
+        if (extras != null) {
+            for (String str3 : extras.keySet()) {
+                if (str3.equals("android.intent.extra.STREAM") && (this.mAllowedFlags & 1) == 0) {
+                    consumer.accept("Allowing Extra Stream requires also allowing at least  FLAG_GRANT_READ_URI_PERMISSION Flag.");
+                } else if (str3.equals("output") && ((~this.mAllowedFlags) & 3) != 0) {
+                    consumer.accept("Allowing Extra Output requires also allowing FLAG_GRANT_READ_URI_PERMISSION and FLAG_GRANT_WRITE_URI_PERMISSION Flags.");
+                } else {
+                    Object obj = extras.get(str3);
+                    Predicate<Object> predicate = this.mAllowedExtras.get(str3);
+                    if (predicate != null && predicate.test(obj)) {
+                        putExtra(intent2, str3, obj);
+                    } else {
+                        consumer.accept("Extra is not allowed. Key: " + str3 + ". Value: " + obj);
+                    }
+                }
+            }
+        }
+        Api16Impl.sanitizeClipData(intent, intent2, this.mAllowedClipData, this.mAllowClipDataText, this.mAllowedClipDataUri, consumer);
+        if (Build.VERSION.SDK_INT >= 29) {
+            if (this.mAllowIdentifier) {
+                Api29Impl.setIdentifier(intent2, Api29Impl.getIdentifier(intent));
+            } else if (Api29Impl.getIdentifier(intent) != null) {
+                consumer.accept("Identifier is not allowed: " + Api29Impl.getIdentifier(intent));
+            }
+        }
+        if (this.mAllowSelector) {
+            Api15Impl.setSelector(intent2, Api15Impl.getSelector(intent));
+        } else if (Api15Impl.getSelector(intent) != null) {
+            consumer.accept("Selector is not allowed: " + Api15Impl.getSelector(intent));
+        }
+        if (this.mAllowSourceBounds) {
+            intent2.setSourceBounds(intent.getSourceBounds());
+        } else if (intent.getSourceBounds() != null) {
+            consumer.accept("SourceBounds is not allowed: " + intent.getSourceBounds());
+        }
+        return intent2;
+    }
+
+    private void putExtra(Intent intent, String str, Object obj) {
+        if (obj == null) {
+            intent.getExtras().putString(str, null);
+            return;
+        }
+        if (obj instanceof Parcelable) {
+            intent.putExtra(str, (Parcelable) obj);
+            return;
+        }
+        if (obj instanceof Parcelable[]) {
+            intent.putExtra(str, (Parcelable[]) obj);
+        } else if (obj instanceof Serializable) {
+            intent.putExtra(str, (Serializable) obj);
+        } else {
+            throw new IllegalArgumentException("Unsupported type " + obj.getClass());
+        }
+    }
+
+    public static final class Builder {
+        private static final int HISTORY_STACK_FLAGS = 2112614400;
+        private static final int RECEIVER_FLAGS = 2015363072;
+        private boolean mAllowAnyComponent;
+        private boolean mAllowIdentifier;
+        private boolean mAllowSelector;
+        private boolean mAllowSomeComponents;
+        private boolean mAllowSourceBounds;
+        private int mAllowedFlags;
+        private Predicate<String> mAllowedActions = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda11
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate and(Predicate predicate) {
+                return Predicate.CC.$default$and(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate negate() {
+                return Predicate.CC.$default$negate(this);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate or(Predicate predicate) {
+                return Predicate.CC.$default$or(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                return IntentSanitizer.Builder.lambda$new$0((String) obj);
+            }
+        };
+        private Predicate<Uri> mAllowedData = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda12
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate and(Predicate predicate) {
+                return Predicate.CC.$default$and(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate negate() {
+                return Predicate.CC.$default$negate(this);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate or(Predicate predicate) {
+                return Predicate.CC.$default$or(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                return IntentSanitizer.Builder.lambda$new$1((Uri) obj);
+            }
+        };
+        private Predicate<String> mAllowedTypes = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda13
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate and(Predicate predicate) {
+                return Predicate.CC.$default$and(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate negate() {
+                return Predicate.CC.$default$negate(this);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate or(Predicate predicate) {
+                return Predicate.CC.$default$or(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                return IntentSanitizer.Builder.lambda$new$2((String) obj);
+            }
+        };
+        private Predicate<String> mAllowedCategories = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda14
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate and(Predicate predicate) {
+                return Predicate.CC.$default$and(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate negate() {
+                return Predicate.CC.$default$negate(this);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate or(Predicate predicate) {
+                return Predicate.CC.$default$or(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                return IntentSanitizer.Builder.lambda$new$3((String) obj);
+            }
+        };
+        private Predicate<String> mAllowedPackages = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda15
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate and(Predicate predicate) {
+                return Predicate.CC.$default$and(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate negate() {
+                return Predicate.CC.$default$negate(this);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate or(Predicate predicate) {
+                return Predicate.CC.$default$or(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                return IntentSanitizer.Builder.lambda$new$4((String) obj);
+            }
+        };
+        private Predicate<ComponentName> mAllowedComponents = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda16
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate and(Predicate predicate) {
+                return Predicate.CC.$default$and(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate negate() {
+                return Predicate.CC.$default$negate(this);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate or(Predicate predicate) {
+                return Predicate.CC.$default$or(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                return IntentSanitizer.Builder.lambda$new$5((ComponentName) obj);
+            }
+        };
+        private Map<String, Predicate<Object>> mAllowedExtras = new HashMap();
+        private boolean mAllowClipDataText = false;
+        private Predicate<Uri> mAllowedClipDataUri = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda17
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate and(Predicate predicate) {
+                return Predicate.CC.$default$and(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate negate() {
+                return Predicate.CC.$default$negate(this);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate or(Predicate predicate) {
+                return Predicate.CC.$default$or(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                return IntentSanitizer.Builder.lambda$new$6((Uri) obj);
+            }
+        };
+        private Predicate<ClipData> mAllowedClipData = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda18
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate and(Predicate predicate) {
+                return Predicate.CC.$default$and(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate negate() {
+                return Predicate.CC.$default$negate(this);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate or(Predicate predicate) {
+                return Predicate.CC.$default$or(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                return IntentSanitizer.Builder.lambda$new$7((ClipData) obj);
+            }
+        };
+
+        static /* synthetic */ boolean lambda$allowAnyComponent$10(ComponentName componentName) {
+            return true;
+        }
+
+        static /* synthetic */ boolean lambda$allowExtra$12(Object obj) {
+            return true;
+        }
+
+        static /* synthetic */ boolean lambda$allowExtra$14(Object obj) {
+            return false;
+        }
+
+        static /* synthetic */ boolean lambda$new$0(String str) {
+            return false;
+        }
+
+        static /* synthetic */ boolean lambda$new$1(Uri uri) {
+            return false;
+        }
+
+        static /* synthetic */ boolean lambda$new$2(String str) {
+            return false;
+        }
+
+        static /* synthetic */ boolean lambda$new$3(String str) {
+            return false;
+        }
+
+        static /* synthetic */ boolean lambda$new$4(String str) {
+            return false;
+        }
+
+        static /* synthetic */ boolean lambda$new$5(ComponentName componentName) {
+            return false;
+        }
+
+        static /* synthetic */ boolean lambda$new$6(Uri uri) {
+            return false;
+        }
+
+        static /* synthetic */ boolean lambda$new$7(ClipData clipData) {
+            return false;
+        }
+
+        public Builder allowClipDataText() {
+            this.mAllowClipDataText = true;
+            return this;
+        }
+
+        public Builder allowFlags(int i) {
+            this.mAllowedFlags = i | this.mAllowedFlags;
+            return this;
+        }
+
+        public Builder allowHistoryStackFlags() {
+            this.mAllowedFlags |= HISTORY_STACK_FLAGS;
+            return this;
+        }
+
+        public Builder allowIdentifier() {
+            this.mAllowIdentifier = true;
+            return this;
+        }
+
+        public Builder allowReceiverFlags() {
+            this.mAllowedFlags |= RECEIVER_FLAGS;
+            return this;
+        }
+
+        public Builder allowSelector() {
+            this.mAllowSelector = true;
+            return this;
+        }
+
+        public Builder allowSourceBounds() {
+            this.mAllowSourceBounds = true;
+            return this;
+        }
+
+        public Builder allowAction(String str) {
+            Preconditions.checkNotNull(str);
+            Objects.requireNonNull(str);
+            allowAction(new IntentSanitizer$Builder$$ExternalSyntheticLambda2(str));
+            return this;
+        }
+
+        public Builder allowAction(Predicate<String> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowedActions = this.mAllowedActions.or(predicate);
+            return this;
+        }
+
+        public Builder allowDataWithAuthority(final String str) {
+            Preconditions.checkNotNull(str);
+            allowData(new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda7
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate and(Predicate predicate) {
+                    return Predicate.CC.$default$and(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate negate() {
+                    return Predicate.CC.$default$negate(this);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate or(Predicate predicate) {
+                    return Predicate.CC.$default$or(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    boolean equals;
+                    equals = str.equals(((Uri) obj).getAuthority());
+                    return equals;
+                }
+            });
+            return this;
+        }
+
+        public Builder allowData(Predicate<Uri> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowedData = this.mAllowedData.or(predicate);
+            return this;
+        }
+
+        public Builder allowType(String str) {
+            Preconditions.checkNotNull(str);
+            Objects.requireNonNull(str);
+            return allowType(new IntentSanitizer$Builder$$ExternalSyntheticLambda2(str));
+        }
+
+        public Builder allowType(Predicate<String> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowedTypes = this.mAllowedTypes.or(predicate);
+            return this;
+        }
+
+        public Builder allowCategory(String str) {
+            Preconditions.checkNotNull(str);
+            Objects.requireNonNull(str);
+            return allowCategory(new IntentSanitizer$Builder$$ExternalSyntheticLambda2(str));
+        }
+
+        public Builder allowCategory(Predicate<String> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowedCategories = this.mAllowedCategories.or(predicate);
+            return this;
+        }
+
+        public Builder allowPackage(String str) {
+            Preconditions.checkNotNull(str);
+            Objects.requireNonNull(str);
+            return allowPackage(new IntentSanitizer$Builder$$ExternalSyntheticLambda2(str));
+        }
+
+        public Builder allowPackage(Predicate<String> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowedPackages = this.mAllowedPackages.or(predicate);
+            return this;
+        }
+
+        public Builder allowComponent(final ComponentName componentName) {
+            Preconditions.checkNotNull(componentName);
+            Objects.requireNonNull(componentName);
+            return allowComponent(new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda9
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate and(Predicate predicate) {
+                    return Predicate.CC.$default$and(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate negate() {
+                    return Predicate.CC.$default$negate(this);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate or(Predicate predicate) {
+                    return Predicate.CC.$default$or(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    return componentName.equals((ComponentName) obj);
+                }
+            });
+        }
+
+        public Builder allowComponent(Predicate<ComponentName> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowSomeComponents = true;
+            this.mAllowedComponents = this.mAllowedComponents.or(predicate);
+            return this;
+        }
+
+        public Builder allowComponentWithPackage(final String str) {
+            Preconditions.checkNotNull(str);
+            return allowComponent(new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda6
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate and(Predicate predicate) {
+                    return Predicate.CC.$default$and(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate negate() {
+                    return Predicate.CC.$default$negate(this);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate or(Predicate predicate) {
+                    return Predicate.CC.$default$or(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    boolean equals;
+                    equals = str.equals(((ComponentName) obj).getPackageName());
+                    return equals;
+                }
+            });
+        }
+
+        public Builder allowAnyComponent() {
+            this.mAllowAnyComponent = true;
+            this.mAllowedComponents = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda4
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate and(Predicate predicate) {
+                    return Predicate.CC.$default$and(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate negate() {
+                    return Predicate.CC.$default$negate(this);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate or(Predicate predicate) {
+                    return Predicate.CC.$default$or(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    return IntentSanitizer.Builder.lambda$allowAnyComponent$10((ComponentName) obj);
+                }
+            };
+            return this;
+        }
+
+        public Builder allowClipDataUriWithAuthority(final String str) {
+            Preconditions.checkNotNull(str);
+            return allowClipDataUri(new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda1
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate and(Predicate predicate) {
+                    return Predicate.CC.$default$and(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate negate() {
+                    return Predicate.CC.$default$negate(this);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate or(Predicate predicate) {
+                    return Predicate.CC.$default$or(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    boolean equals;
+                    equals = str.equals(((Uri) obj).getAuthority());
+                    return equals;
+                }
+            });
+        }
+
+        public Builder allowClipDataUri(Predicate<Uri> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowedClipDataUri = this.mAllowedClipDataUri.or(predicate);
+            return this;
+        }
+
+        public Builder allowClipData(Predicate<ClipData> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowedClipData = this.mAllowedClipData.or(predicate);
+            return this;
+        }
+
+        public Builder allowExtra(String str, Class<?> cls) {
+            return allowExtra(str, cls, new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda10
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate and(Predicate predicate) {
+                    return Predicate.CC.$default$and(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate negate() {
+                    return Predicate.CC.$default$negate(this);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate or(Predicate predicate) {
+                    return Predicate.CC.$default$or(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    return IntentSanitizer.Builder.lambda$allowExtra$12(obj);
+                }
+            });
+        }
+
+        public <T> Builder allowExtra(String str, final Class<T> cls, final Predicate<T> predicate) {
+            Preconditions.checkNotNull(str);
+            Preconditions.checkNotNull(cls);
+            Preconditions.checkNotNull(predicate);
+            return allowExtra(str, new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda5
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate and(Predicate predicate2) {
+                    return Predicate.CC.$default$and(this, predicate2);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate negate() {
+                    return Predicate.CC.$default$negate(this);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate or(Predicate predicate2) {
+                    return Predicate.CC.$default$or(this, predicate2);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    return IntentSanitizer.Builder.lambda$allowExtra$13(cls, predicate, obj);
+                }
+            });
+        }
+
+        static /* synthetic */ boolean lambda$allowExtra$13(Class cls, Predicate predicate, Object obj) {
+            return cls.isInstance(obj) && predicate.test(cls.cast(obj));
+        }
+
+        public Builder allowExtra(String str, Predicate<Object> predicate) {
+            Preconditions.checkNotNull(str);
+            Preconditions.checkNotNull(predicate);
+            Predicate<Object> predicate2 = this.mAllowedExtras.get(str);
+            if (predicate2 == null) {
+                predicate2 = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda0
+                    @Override // androidx.core.util.Predicate
+                    public /* synthetic */ Predicate and(Predicate predicate3) {
+                        return Predicate.CC.$default$and(this, predicate3);
+                    }
+
+                    @Override // androidx.core.util.Predicate
+                    public /* synthetic */ Predicate negate() {
+                        return Predicate.CC.$default$negate(this);
+                    }
+
+                    @Override // androidx.core.util.Predicate
+                    public /* synthetic */ Predicate or(Predicate predicate3) {
+                        return Predicate.CC.$default$or(this, predicate3);
+                    }
+
+                    @Override // androidx.core.util.Predicate
+                    public final boolean test(Object obj) {
+                        return IntentSanitizer.Builder.lambda$allowExtra$14(obj);
+                    }
+                };
+            }
+            this.mAllowedExtras.put(str, predicate2.or(predicate));
+            return this;
+        }
+
+        public Builder allowExtraStreamUriWithAuthority(final String str) {
+            Preconditions.checkNotNull(str);
+            allowExtra("android.intent.extra.STREAM", Uri.class, new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda3
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate and(Predicate predicate) {
+                    return Predicate.CC.$default$and(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate negate() {
+                    return Predicate.CC.$default$negate(this);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate or(Predicate predicate) {
+                    return Predicate.CC.$default$or(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    boolean equals;
+                    equals = str.equals(((Uri) obj).getAuthority());
+                    return equals;
+                }
+            });
+            return this;
+        }
+
+        public Builder allowExtraStream(Predicate<Uri> predicate) {
+            allowExtra("android.intent.extra.STREAM", Uri.class, predicate);
+            return this;
+        }
+
+        public Builder allowExtraOutput(final String str) {
+            allowExtra("output", Uri.class, new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda8
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate and(Predicate predicate) {
+                    return Predicate.CC.$default$and(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate negate() {
+                    return Predicate.CC.$default$negate(this);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public /* synthetic */ Predicate or(Predicate predicate) {
+                    return Predicate.CC.$default$or(this, predicate);
+                }
+
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    boolean equals;
+                    equals = str.equals(((Uri) obj).getAuthority());
+                    return equals;
+                }
+            });
+            return this;
+        }
+
+        public Builder allowExtraOutput(Predicate<Uri> predicate) {
+            allowExtra("output", Uri.class, predicate);
+            return this;
+        }
+
+        public IntentSanitizer build() {
+            boolean z = this.mAllowAnyComponent;
+            if ((z && this.mAllowSomeComponents) || (!z && !this.mAllowSomeComponents)) {
+                throw new SecurityException("You must call either allowAnyComponent or one or more of the allowComponent methods; but not both.");
+            }
+            IntentSanitizer intentSanitizer = new IntentSanitizer();
+            intentSanitizer.mAllowedFlags = this.mAllowedFlags;
+            intentSanitizer.mAllowedActions = this.mAllowedActions;
+            intentSanitizer.mAllowedData = this.mAllowedData;
+            intentSanitizer.mAllowedTypes = this.mAllowedTypes;
+            intentSanitizer.mAllowedCategories = this.mAllowedCategories;
+            intentSanitizer.mAllowedPackages = this.mAllowedPackages;
+            intentSanitizer.mAllowAnyComponent = this.mAllowAnyComponent;
+            intentSanitizer.mAllowedComponents = this.mAllowedComponents;
+            intentSanitizer.mAllowedExtras = this.mAllowedExtras;
+            intentSanitizer.mAllowClipDataText = this.mAllowClipDataText;
+            intentSanitizer.mAllowedClipDataUri = this.mAllowedClipDataUri;
+            intentSanitizer.mAllowedClipData = this.mAllowedClipData;
+            intentSanitizer.mAllowIdentifier = this.mAllowIdentifier;
+            intentSanitizer.mAllowSelector = this.mAllowSelector;
+            intentSanitizer.mAllowSourceBounds = this.mAllowSourceBounds;
+            return intentSanitizer;
+        }
+    }
+
+    private static class Api15Impl {
+        private Api15Impl() {
+        }
+
+        static void setSelector(Intent intent, Intent intent2) {
+            intent.setSelector(intent2);
+        }
+
+        static Intent getSelector(Intent intent) {
+            return intent.getSelector();
+        }
+    }
+
+    private static class Api16Impl {
+        private Api16Impl() {
+        }
+
+        /* JADX WARN: Removed duplicated region for block: B:29:0x00b5  */
+        /* JADX WARN: Removed duplicated region for block: B:31:0x00c4  */
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        static void sanitizeClipData(android.content.Intent r7, android.content.Intent r8, androidx.core.util.Predicate<android.content.ClipData> r9, boolean r10, androidx.core.util.Predicate<android.net.Uri> r11, androidx.core.util.Consumer<java.lang.String> r12) {
+            /*
+                android.content.ClipData r7 = r7.getClipData()
+                if (r7 != 0) goto L7
+                return
+            L7:
+                if (r9 == 0) goto L14
+                boolean r9 = r9.test(r7)
+                if (r9 == 0) goto L14
+                r8.setClipData(r7)
+                goto Ld5
+            L14:
+                r9 = 0
+                r0 = 0
+                r1 = r9
+            L17:
+                int r2 = r7.getItemCount()
+                if (r0 >= r2) goto Ld0
+                android.content.ClipData$Item r2 = r7.getItemAt(r0)
+                int r3 = android.os.Build.VERSION.SDK_INT
+                r4 = 31
+                if (r3 < r4) goto L2b
+                androidx.core.content.IntentSanitizer.Api16Impl.Api31Impl.checkOtherMembers(r0, r2, r12)
+                goto L2e
+            L2b:
+                checkOtherMembers(r0, r2, r12)
+            L2e:
+                if (r10 == 0) goto L35
+                java.lang.CharSequence r3 = r2.getText()
+                goto L59
+            L35:
+                java.lang.CharSequence r3 = r2.getText()
+                if (r3 == 0) goto L58
+                java.lang.StringBuilder r3 = new java.lang.StringBuilder
+                java.lang.String r4 = "Item text cannot contain value. Item position: "
+                r3.<init>(r4)
+                r3.append(r0)
+                java.lang.String r4 = ". Text: "
+                r3.append(r4)
+                java.lang.CharSequence r4 = r2.getText()
+                r3.append(r4)
+                java.lang.String r3 = r3.toString()
+                r12.accept(r3)
+            L58:
+                r3 = r9
+            L59:
+                java.lang.String r4 = ". URI: "
+                java.lang.String r5 = "Item URI is not allowed. Item position: "
+                if (r11 != 0) goto L7f
+                android.net.Uri r6 = r2.getUri()
+                if (r6 == 0) goto La9
+                java.lang.StringBuilder r6 = new java.lang.StringBuilder
+                r6.<init>(r5)
+                r6.append(r0)
+                r6.append(r4)
+                android.net.Uri r2 = r2.getUri()
+                r6.append(r2)
+                java.lang.String r2 = r6.toString()
+                r12.accept(r2)
+                goto La9
+            L7f:
+                android.net.Uri r6 = r2.getUri()
+                if (r6 == 0) goto Lab
+                android.net.Uri r6 = r2.getUri()
+                boolean r6 = r11.test(r6)
+                if (r6 == 0) goto L90
+                goto Lab
+            L90:
+                java.lang.StringBuilder r6 = new java.lang.StringBuilder
+                r6.<init>(r5)
+                r6.append(r0)
+                r6.append(r4)
+                android.net.Uri r2 = r2.getUri()
+                r6.append(r2)
+                java.lang.String r2 = r6.toString()
+                r12.accept(r2)
+            La9:
+                r2 = r9
+                goto Laf
+            Lab:
+                android.net.Uri r2 = r2.getUri()
+            Laf:
+                if (r3 != 0) goto Lb3
+                if (r2 == 0) goto Lcc
+            Lb3:
+                if (r1 != 0) goto Lc4
+                android.content.ClipData r1 = new android.content.ClipData
+                android.content.ClipDescription r4 = r7.getDescription()
+                android.content.ClipData$Item r5 = new android.content.ClipData$Item
+                r5.<init>(r3, r9, r2)
+                r1.<init>(r4, r5)
+                goto Lcc
+            Lc4:
+                android.content.ClipData$Item r4 = new android.content.ClipData$Item
+                r4.<init>(r3, r9, r2)
+                r1.addItem(r4)
+            Lcc:
+                int r0 = r0 + 1
+                goto L17
+            Ld0:
+                if (r1 == 0) goto Ld5
+                r8.setClipData(r1)
+            Ld5:
+                return
+            */
+            throw new UnsupportedOperationException("Method not decompiled: androidx.core.content.IntentSanitizer.Api16Impl.sanitizeClipData(android.content.Intent, android.content.Intent, androidx.core.util.Predicate, boolean, androidx.core.util.Predicate, androidx.core.util.Consumer):void");
+        }
+
+        private static void checkOtherMembers(int i, ClipData.Item item, Consumer<String> consumer) {
+            if (item.getHtmlText() == null && item.getIntent() == null) {
+                return;
+            }
+            consumer.accept("ClipData item at position " + i + " contains htmlText, textLinks or intent: " + item);
+        }
+
+        private static class Api31Impl {
+            private Api31Impl() {
+            }
+
+            static void checkOtherMembers(int i, ClipData.Item item, Consumer<String> consumer) {
+                TextLinks textLinks;
+                if (item.getHtmlText() == null && item.getIntent() == null) {
+                    textLinks = item.getTextLinks();
+                    if (textLinks == null) {
+                        return;
+                    }
+                }
+                consumer.accept("ClipData item at position " + i + " contains htmlText, textLinks or intent: " + item);
+            }
+        }
+    }
+
+    private static class Api29Impl {
+        private Api29Impl() {
+        }
+
+        static Intent setIdentifier(Intent intent, String str) {
+            return intent.setIdentifier(str);
+        }
+
+        static String getIdentifier(Intent intent) {
+            return intent.getIdentifier();
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/LocusIdCompat.java

@@ -0,0 +1,74 @@
+package androidx.core.content;
+
+import android.content.LocusId;
+import android.os.Build;
+import androidx.core.util.Preconditions;
+
+/* loaded from: classes.dex */
+public final class LocusIdCompat {
+    private final String mId;
+    private final LocusId mWrapped;
+
+    public String getId() {
+        return this.mId;
+    }
+
+    public LocusId toLocusId() {
+        return this.mWrapped;
+    }
+
+    public LocusIdCompat(String str) {
+        this.mId = (String) Preconditions.checkStringNotEmpty(str, "id cannot be empty");
+        if (Build.VERSION.SDK_INT >= 29) {
+            this.mWrapped = Api29Impl.create(str);
+        } else {
+            this.mWrapped = null;
+        }
+    }
+
+    public int hashCode() {
+        String str = this.mId;
+        return 31 + (str == null ? 0 : str.hashCode());
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        }
+        LocusIdCompat locusIdCompat = (LocusIdCompat) obj;
+        String str = this.mId;
+        if (str == null) {
+            return locusIdCompat.mId == null;
+        }
+        return str.equals(locusIdCompat.mId);
+    }
+
+    public String toString() {
+        return "LocusIdCompat[" + getSanitizedId() + "]";
+    }
+
+    public static LocusIdCompat toLocusIdCompat(LocusId locusId) {
+        Preconditions.checkNotNull(locusId, "locusId cannot be null");
+        return new LocusIdCompat((String) Preconditions.checkStringNotEmpty(Api29Impl.getId(locusId), "id cannot be empty"));
+    }
+
+    private String getSanitizedId() {
+        return this.mId.length() + "_chars";
+    }
+
+    private static class Api29Impl {
+        private Api29Impl() {
+        }
+
+        static LocusId create(String str) {
+            return new LocusId(str);
+        }
+
+        static String getId(LocusId locusId) {
+            return locusId.getId();
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/MimeTypeFilter.java

@@ -0,0 +1,72 @@
+package androidx.core.content;
+
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+public final class MimeTypeFilter {
+    private MimeTypeFilter() {
+    }
+
+    private static boolean mimeTypeAgainstFilter(String[] strArr, String[] strArr2) {
+        if (strArr2.length != 2) {
+            throw new IllegalArgumentException("Ill-formatted MIME type filter. Must be type/subtype.");
+        }
+        if (strArr2[0].isEmpty() || strArr2[1].isEmpty()) {
+            throw new IllegalArgumentException("Ill-formatted MIME type filter. Type or subtype empty.");
+        }
+        if (strArr.length != 2) {
+            return false;
+        }
+        if ("*".equals(strArr2[0]) || strArr2[0].equals(strArr[0])) {
+            return "*".equals(strArr2[1]) || strArr2[1].equals(strArr[1]);
+        }
+        return false;
+    }
+
+    public static boolean matches(String str, String str2) {
+        if (str == null) {
+            return false;
+        }
+        return mimeTypeAgainstFilter(str.split("/"), str2.split("/"));
+    }
+
+    public static String matches(String str, String[] strArr) {
+        if (str == null) {
+            return null;
+        }
+        String[] split = str.split("/");
+        for (String str2 : strArr) {
+            if (mimeTypeAgainstFilter(split, str2.split("/"))) {
+                return str2;
+            }
+        }
+        return null;
+    }
+
+    public static String matches(String[] strArr, String str) {
+        if (strArr == null) {
+            return null;
+        }
+        String[] split = str.split("/");
+        for (String str2 : strArr) {
+            if (mimeTypeAgainstFilter(str2.split("/"), split)) {
+                return str2;
+            }
+        }
+        return null;
+    }
+
+    public static String[] matchesMany(String[] strArr, String str) {
+        if (strArr == null) {
+            return new String[0];
+        }
+        ArrayList arrayList = new ArrayList();
+        String[] split = str.split("/");
+        for (String str2 : strArr) {
+            if (mimeTypeAgainstFilter(str2.split("/"), split)) {
+                arrayList.add(str2);
+            }
+        }
+        return (String[]) arrayList.toArray(new String[arrayList.size()]);
+    }
+}

02-Easy5/E5/sources/androidx/core/content/OnConfigurationChangedProvider.java

@@ -0,0 +1,11 @@
+package androidx.core.content;
+
+import android.content.res.Configuration;
+import androidx.core.util.Consumer;
+
+/* loaded from: classes.dex */
+public interface OnConfigurationChangedProvider {
+    void addOnConfigurationChangedListener(Consumer<Configuration> consumer);
+
+    void removeOnConfigurationChangedListener(Consumer<Configuration> consumer);
+}

02-Easy5/E5/sources/androidx/core/content/OnTrimMemoryProvider.java

@@ -0,0 +1,10 @@
+package androidx.core.content;
+
+import androidx.core.util.Consumer;
+
+/* loaded from: classes.dex */
+public interface OnTrimMemoryProvider {
+    void addOnTrimMemoryListener(Consumer<Integer> consumer);
+
+    void removeOnTrimMemoryListener(Consumer<Integer> consumer);
+}

02-Easy5/E5/sources/androidx/core/content/PackageManagerCompat.java

@@ -0,0 +1,103 @@
+package androidx.core.content;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.net.Uri;
+import android.os.Build;
+import android.util.Log;
+import androidx.concurrent.futures.ResolvableFuture;
+import androidx.core.os.UserManagerCompat;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.Iterator;
+import java.util.concurrent.Executors;
+
+/* loaded from: classes.dex */
+public final class PackageManagerCompat {
+    public static final String ACTION_PERMISSION_REVOCATION_SETTINGS = "android.intent.action.AUTO_REVOKE_PERMISSIONS";
+    public static final String LOG_TAG = "PackageManagerCompat";
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface UnusedAppRestrictionsStatus {
+    }
+
+    private PackageManagerCompat() {
+    }
+
+    public static ListenableFuture<Integer> getUnusedAppRestrictionsStatus(Context context) {
+        ResolvableFuture<Integer> create = ResolvableFuture.create();
+        if (!UserManagerCompat.isUserUnlocked(context)) {
+            create.set(0);
+            Log.e(LOG_TAG, "User is in locked direct boot mode");
+            return create;
+        }
+        if (!areUnusedAppRestrictionsAvailable(context.getPackageManager())) {
+            create.set(1);
+            return create;
+        }
+        int i = context.getApplicationInfo().targetSdkVersion;
+        if (i < 30) {
+            create.set(0);
+            Log.e(LOG_TAG, "Target SDK version below API 30");
+            return create;
+        }
+        if (Build.VERSION.SDK_INT >= 31) {
+            if (Api30Impl.areUnusedAppRestrictionsEnabled(context)) {
+                create.set(Integer.valueOf(i >= 31 ? 5 : 4));
+            } else {
+                create.set(2);
+            }
+            return create;
+        }
+        if (Build.VERSION.SDK_INT == 30) {
+            create.set(Integer.valueOf(Api30Impl.areUnusedAppRestrictionsEnabled(context) ? 4 : 2));
+            return create;
+        }
+        final UnusedAppRestrictionsBackportServiceConnection unusedAppRestrictionsBackportServiceConnection = new UnusedAppRestrictionsBackportServiceConnection(context);
+        create.addListener(new Runnable() { // from class: androidx.core.content.PackageManagerCompat$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                UnusedAppRestrictionsBackportServiceConnection.this.disconnectFromService();
+            }
+        }, Executors.newSingleThreadExecutor());
+        unusedAppRestrictionsBackportServiceConnection.connectAndFetchResult(create);
+        return create;
+    }
+
+    public static boolean areUnusedAppRestrictionsAvailable(PackageManager packageManager) {
+        boolean z = Build.VERSION.SDK_INT >= 30;
+        boolean z2 = Build.VERSION.SDK_INT >= 23 && Build.VERSION.SDK_INT < 30;
+        boolean z3 = getPermissionRevocationVerifierApp(packageManager) != null;
+        if (z) {
+            return true;
+        }
+        return z2 && z3;
+    }
+
+    public static String getPermissionRevocationVerifierApp(PackageManager packageManager) {
+        String str = null;
+        Iterator<ResolveInfo> it = packageManager.queryIntentActivities(new Intent(ACTION_PERMISSION_REVOCATION_SETTINGS).setData(Uri.fromParts("package", "com.example", null)), 0).iterator();
+        while (it.hasNext()) {
+            String str2 = it.next().activityInfo.packageName;
+            if (packageManager.checkPermission("android.permission.PACKAGE_VERIFICATION_AGENT", str2) == 0) {
+                if (str != null) {
+                    return str;
+                }
+                str = str2;
+            }
+        }
+        return str;
+    }
+
+    private static class Api30Impl {
+        private Api30Impl() {
+        }
+
+        static boolean areUnusedAppRestrictionsEnabled(Context context) {
+            return !context.getPackageManager().isAutoRevokeWhitelisted();
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/PermissionChecker.java

@@ -0,0 +1,64 @@
+package androidx.core.content;
+
+import android.content.Context;
+import android.os.Binder;
+import android.os.Process;
+import androidx.core.app.AppOpsManagerCompat;
+import androidx.core.util.ObjectsCompat;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes.dex */
+public final class PermissionChecker {
+    public static final int PERMISSION_DENIED = -1;
+    public static final int PERMISSION_DENIED_APP_OP = -2;
+    public static final int PERMISSION_GRANTED = 0;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface PermissionResult {
+    }
+
+    private PermissionChecker() {
+    }
+
+    public static int checkPermission(Context context, String str, int i, int i2, String str2) {
+        int noteProxyOpNoThrow;
+        if (context.checkPermission(str, i, i2) == -1) {
+            return -1;
+        }
+        String permissionToOp = AppOpsManagerCompat.permissionToOp(str);
+        if (permissionToOp == null) {
+            return 0;
+        }
+        if (str2 == null) {
+            String[] packagesForUid = context.getPackageManager().getPackagesForUid(i2);
+            if (packagesForUid == null || packagesForUid.length <= 0) {
+                return -1;
+            }
+            str2 = packagesForUid[0];
+        }
+        int myUid = Process.myUid();
+        String packageName = context.getPackageName();
+        if (myUid == i2 && ObjectsCompat.equals(packageName, str2)) {
+            noteProxyOpNoThrow = AppOpsManagerCompat.checkOrNoteProxyOp(context, i2, permissionToOp, str2);
+        } else {
+            noteProxyOpNoThrow = AppOpsManagerCompat.noteProxyOpNoThrow(context, permissionToOp, str2);
+        }
+        return noteProxyOpNoThrow == 0 ? 0 : -2;
+    }
+
+    public static int checkSelfPermission(Context context, String str) {
+        return checkPermission(context, str, Process.myPid(), Process.myUid(), context.getPackageName());
+    }
+
+    public static int checkCallingPermission(Context context, String str, String str2) {
+        if (Binder.getCallingPid() == Process.myPid()) {
+            return -1;
+        }
+        return checkPermission(context, str, Binder.getCallingPid(), Binder.getCallingUid(), str2);
+    }
+
+    public static int checkCallingOrSelfPermission(Context context, String str) {
+        return checkPermission(context, str, Binder.getCallingPid(), Binder.getCallingUid(), Binder.getCallingPid() == Process.myPid() ? context.getPackageName() : null);
+    }
+}

02-Easy5/E5/sources/androidx/core/content/SharedPreferencesCompat.java

@@ -0,0 +1,46 @@
+package androidx.core.content;
+
+import android.content.SharedPreferences;
+
+@Deprecated
+/* loaded from: classes.dex */
+public final class SharedPreferencesCompat {
+
+    @Deprecated
+    public static final class EditorCompat {
+        private static EditorCompat sInstance;
+        private final Helper mHelper = new Helper();
+
+        private static class Helper {
+            Helper() {
+            }
+
+            public void apply(SharedPreferences.Editor editor) {
+                try {
+                    editor.apply();
+                } catch (AbstractMethodError unused) {
+                    editor.commit();
+                }
+            }
+        }
+
+        private EditorCompat() {
+        }
+
+        @Deprecated
+        public static EditorCompat getInstance() {
+            if (sInstance == null) {
+                sInstance = new EditorCompat();
+            }
+            return sInstance;
+        }
+
+        @Deprecated
+        public void apply(SharedPreferences.Editor editor) {
+            this.mHelper.apply(editor);
+        }
+    }
+
+    private SharedPreferencesCompat() {
+    }
+}

02-Easy5/E5/sources/androidx/core/content/SharedPreferencesKt.java

@@ -0,0 +1,41 @@
+package androidx.core.content;
+
+import android.content.SharedPreferences;
+import kotlin.Metadata;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* compiled from: SharedPreferences.kt */
+@Metadata(d1 = {"\u0000 \n\u0000\n\u0002\u0010\u0002\n\u0002\u0018\u0002\n\u0000\n\u0002\u0010\u000b\n\u0000\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0000\u001a3\u0010\u0000\u001a\u00020\u0001*\u00020\u00022\b\b\u0002\u0010\u0003\u001a\u00020\u00042\u0017\u0010\u0005\u001a\u0013\u0012\u0004\u0012\u00020\u0007\u0012\u0004\u0012\u00020\u00010\u0006¢\u0006\u0002\b\bH\u0087\bø\u0001\u0000\u0082\u0002\u0007\n\u0005\b\u009920\u0001¨\u0006\t"}, d2 = {"edit", "", "Landroid/content/SharedPreferences;", "commit", "", "action", "Lkotlin/Function1;", "Landroid/content/SharedPreferences$Editor;", "Lkotlin/ExtensionFunctionType;", "core-ktx_release"}, k = 2, mv = {1, 7, 1}, xi = 48)
+/* loaded from: classes.dex */
+public final class SharedPreferencesKt {
+    public static /* synthetic */ void edit$default(SharedPreferences sharedPreferences, boolean z, Function1 action, int i, Object obj) {
+        if ((i & 1) != 0) {
+            z = false;
+        }
+        Intrinsics.checkNotNullParameter(sharedPreferences, "<this>");
+        Intrinsics.checkNotNullParameter(action, "action");
+        SharedPreferences.Editor editor = sharedPreferences.edit();
+        Intrinsics.checkNotNullExpressionValue(editor, "editor");
+        action.invoke(editor);
+        if (z) {
+            editor.commit();
+        } else {
+            editor.apply();
+        }
+    }
+
+    public static final void edit(SharedPreferences sharedPreferences, boolean z, Function1<? super SharedPreferences.Editor, Unit> action) {
+        Intrinsics.checkNotNullParameter(sharedPreferences, "<this>");
+        Intrinsics.checkNotNullParameter(action, "action");
+        SharedPreferences.Editor editor = sharedPreferences.edit();
+        Intrinsics.checkNotNullExpressionValue(editor, "editor");
+        action.invoke(editor);
+        if (z) {
+            editor.commit();
+        } else {
+            editor.apply();
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/UnusedAppRestrictionsBackportCallback.java

@@ -0,0 +1,17 @@
+package androidx.core.content;
+
+import android.os.RemoteException;
+import androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportCallback;
+
+/* loaded from: classes.dex */
+public class UnusedAppRestrictionsBackportCallback {
+    private IUnusedAppRestrictionsBackportCallback mCallback;
+
+    public UnusedAppRestrictionsBackportCallback(IUnusedAppRestrictionsBackportCallback iUnusedAppRestrictionsBackportCallback) {
+        this.mCallback = iUnusedAppRestrictionsBackportCallback;
+    }
+
+    public void onResult(boolean z, boolean z2) throws RemoteException {
+        this.mCallback.onIsPermissionRevocationEnabledForAppResult(z, z2);
+    }
+}

02-Easy5/E5/sources/androidx/core/content/UnusedAppRestrictionsBackportService.java

@@ -0,0 +1,29 @@
+package androidx.core.content;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.IBinder;
+import android.os.RemoteException;
+import androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportCallback;
+import androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportService;
+
+/* loaded from: classes.dex */
+public abstract class UnusedAppRestrictionsBackportService extends Service {
+    public static final String ACTION_UNUSED_APP_RESTRICTIONS_BACKPORT_CONNECTION = "android.support.unusedapprestrictions.action.CustomUnusedAppRestrictionsBackportService";
+    private IUnusedAppRestrictionsBackportService.Stub mBinder = new IUnusedAppRestrictionsBackportService.Stub() { // from class: androidx.core.content.UnusedAppRestrictionsBackportService.1
+        @Override // androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportService
+        public void isPermissionRevocationEnabledForApp(IUnusedAppRestrictionsBackportCallback iUnusedAppRestrictionsBackportCallback) throws RemoteException {
+            if (iUnusedAppRestrictionsBackportCallback == null) {
+                return;
+            }
+            UnusedAppRestrictionsBackportService.this.isPermissionRevocationEnabled(new UnusedAppRestrictionsBackportCallback(iUnusedAppRestrictionsBackportCallback));
+        }
+    };
+
+    protected abstract void isPermissionRevocationEnabled(UnusedAppRestrictionsBackportCallback unusedAppRestrictionsBackportCallback);
+
+    @Override // android.app.Service
+    public IBinder onBind(Intent intent) {
+        return this.mBinder;
+    }
+}

02-Easy5/E5/sources/androidx/core/content/UnusedAppRestrictionsBackportServiceConnection.java

@@ -0,0 +1,73 @@
+package androidx.core.content;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.util.Log;
+import androidx.concurrent.futures.ResolvableFuture;
+import androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportCallback;
+import androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportService;
+
+/* loaded from: classes.dex */
+class UnusedAppRestrictionsBackportServiceConnection implements ServiceConnection {
+    private final Context mContext;
+    ResolvableFuture<Integer> mResultFuture;
+    IUnusedAppRestrictionsBackportService mUnusedAppRestrictionsService = null;
+    private boolean mHasBoundService = false;
+
+    @Override // android.content.ServiceConnection
+    public void onServiceDisconnected(ComponentName componentName) {
+        this.mUnusedAppRestrictionsService = null;
+    }
+
+    UnusedAppRestrictionsBackportServiceConnection(Context context) {
+        this.mContext = context;
+    }
+
+    @Override // android.content.ServiceConnection
+    public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
+        IUnusedAppRestrictionsBackportService asInterface = IUnusedAppRestrictionsBackportService.Stub.asInterface(iBinder);
+        this.mUnusedAppRestrictionsService = asInterface;
+        try {
+            asInterface.isPermissionRevocationEnabledForApp(getBackportCallback());
+        } catch (RemoteException unused) {
+            this.mResultFuture.set(0);
+        }
+    }
+
+    public void connectAndFetchResult(ResolvableFuture<Integer> resolvableFuture) {
+        if (this.mHasBoundService) {
+            throw new IllegalStateException("Each UnusedAppRestrictionsBackportServiceConnection can only be bound once.");
+        }
+        this.mHasBoundService = true;
+        this.mResultFuture = resolvableFuture;
+        this.mContext.bindService(new Intent(UnusedAppRestrictionsBackportService.ACTION_UNUSED_APP_RESTRICTIONS_BACKPORT_CONNECTION).setPackage(PackageManagerCompat.getPermissionRevocationVerifierApp(this.mContext.getPackageManager())), this, 1);
+    }
+
+    public void disconnectFromService() {
+        if (!this.mHasBoundService) {
+            throw new IllegalStateException("bindService must be called before unbind");
+        }
+        this.mHasBoundService = false;
+        this.mContext.unbindService(this);
+    }
+
+    private IUnusedAppRestrictionsBackportCallback getBackportCallback() {
+        return new IUnusedAppRestrictionsBackportCallback.Stub() { // from class: androidx.core.content.UnusedAppRestrictionsBackportServiceConnection.1
+            @Override // androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportCallback
+            public void onIsPermissionRevocationEnabledForAppResult(boolean z, boolean z2) throws RemoteException {
+                if (!z) {
+                    UnusedAppRestrictionsBackportServiceConnection.this.mResultFuture.set(0);
+                    Log.e(PackageManagerCompat.LOG_TAG, "Unable to retrieve the permission revocation setting from the backport");
+                } else if (z2) {
+                    UnusedAppRestrictionsBackportServiceConnection.this.mResultFuture.set(3);
+                } else {
+                    UnusedAppRestrictionsBackportServiceConnection.this.mResultFuture.set(2);
+                }
+            }
+        };
+    }
+}

02-Easy5/E5/sources/androidx/core/content/UnusedAppRestrictionsConstants.java

@@ -0,0 +1,14 @@
+package androidx.core.content;
+
+/* loaded from: classes.dex */
+public final class UnusedAppRestrictionsConstants {
+    public static final int API_30 = 4;
+    public static final int API_30_BACKPORT = 3;
+    public static final int API_31 = 5;
+    public static final int DISABLED = 2;
+    public static final int ERROR = 0;
+    public static final int FEATURE_NOT_AVAILABLE = 1;
+
+    private UnusedAppRestrictionsConstants() {
+    }
+}

02-Easy5/E5/sources/androidx/core/content/UriMatcherCompat.java

@@ -0,0 +1,39 @@
+package androidx.core.content;
+
+import android.content.UriMatcher;
+import android.net.Uri;
+import androidx.core.util.Predicate;
+
+/* loaded from: classes.dex */
+public class UriMatcherCompat {
+    private UriMatcherCompat() {
+    }
+
+    public static Predicate<Uri> asPredicate(final UriMatcher uriMatcher) {
+        return new Predicate() { // from class: androidx.core.content.UriMatcherCompat$$ExternalSyntheticLambda0
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate and(Predicate predicate) {
+                return Predicate.CC.$default$and(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate negate() {
+                return Predicate.CC.$default$negate(this);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public /* synthetic */ Predicate or(Predicate predicate) {
+                return Predicate.CC.$default$or(this, predicate);
+            }
+
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                return UriMatcherCompat.lambda$asPredicate$0(uriMatcher, (Uri) obj);
+            }
+        };
+    }
+
+    static /* synthetic */ boolean lambda$asPredicate$0(UriMatcher uriMatcher, Uri uri) {
+        return uriMatcher.match(uri) != -1;
+    }
+}

02-Easy5/E5/sources/androidx/core/content/pm/ActivityInfoCompat.java

@@ -0,0 +1,12 @@
+package androidx.core.content.pm;
+
+@Deprecated
+/* loaded from: classes.dex */
+public final class ActivityInfoCompat {
+
+    @Deprecated
+    public static final int CONFIG_UI_MODE = 512;
+
+    private ActivityInfoCompat() {
+    }
+}

02-Easy5/E5/sources/androidx/core/content/pm/PackageInfoCompat.java

@@ -0,0 +1,148 @@
+package androidx.core.content.pm;
+
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.Signature;
+import android.content.pm.SigningInfo;
+import android.os.Build;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+public final class PackageInfoCompat {
+    public static long getLongVersionCode(PackageInfo packageInfo) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.getLongVersionCode(packageInfo);
+        }
+        return packageInfo.versionCode;
+    }
+
+    public static List<Signature> getSignatures(PackageManager packageManager, String str) throws PackageManager.NameNotFoundException {
+        Signature[] signatureArr;
+        SigningInfo signingInfo;
+        if (Build.VERSION.SDK_INT >= 28) {
+            signingInfo = packageManager.getPackageInfo(str, 134217728).signingInfo;
+            if (Api28Impl.hasMultipleSigners(signingInfo)) {
+                signatureArr = Api28Impl.getApkContentsSigners(signingInfo);
+            } else {
+                signatureArr = Api28Impl.getSigningCertificateHistory(signingInfo);
+            }
+        } else {
+            signatureArr = packageManager.getPackageInfo(str, 64).signatures;
+        }
+        if (signatureArr == null) {
+            return Collections.emptyList();
+        }
+        return Arrays.asList(signatureArr);
+    }
+
+    public static boolean hasSignatures(PackageManager packageManager, String str, Map<byte[], Integer> map, boolean z) throws PackageManager.NameNotFoundException {
+        byte[][] bArr;
+        if (map.isEmpty()) {
+            return false;
+        }
+        Set<byte[]> keySet = map.keySet();
+        for (byte[] bArr2 : keySet) {
+            if (bArr2 == null) {
+                throw new IllegalArgumentException("Cert byte array cannot be null when verifying " + str);
+            }
+            Integer num = map.get(bArr2);
+            if (num == null) {
+                throw new IllegalArgumentException("Type must be specified for cert when verifying " + str);
+            }
+            int intValue = num.intValue();
+            if (intValue != 0 && intValue != 1) {
+                throw new IllegalArgumentException("Unsupported certificate type " + num + " when verifying " + str);
+            }
+        }
+        List<Signature> signatures = getSignatures(packageManager, str);
+        if (!z && Build.VERSION.SDK_INT >= 28) {
+            for (byte[] bArr3 : keySet) {
+                if (!Api28Impl.hasSigningCertificate(packageManager, str, bArr3, map.get(bArr3).intValue())) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (signatures.size() != 0 && map.size() <= signatures.size() && (!z || map.size() == signatures.size())) {
+            if (map.containsValue(1)) {
+                bArr = new byte[signatures.size()][];
+                for (int i = 0; i < signatures.size(); i++) {
+                    bArr[i] = computeSHA256Digest(signatures.get(i).toByteArray());
+                }
+            } else {
+                bArr = null;
+            }
+            Iterator<byte[]> it = keySet.iterator();
+            if (it.hasNext()) {
+                byte[] next = it.next();
+                Integer num2 = map.get(next);
+                int intValue2 = num2.intValue();
+                if (intValue2 != 0) {
+                    if (intValue2 == 1) {
+                        if (!byteArrayContains(bArr, next)) {
+                            return false;
+                        }
+                    } else {
+                        throw new IllegalArgumentException("Unsupported certificate type " + num2);
+                    }
+                } else if (!signatures.contains(new Signature(next))) {
+                    return false;
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean byteArrayContains(byte[][] bArr, byte[] bArr2) {
+        for (byte[] bArr3 : bArr) {
+            if (Arrays.equals(bArr2, bArr3)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static byte[] computeSHA256Digest(byte[] bArr) {
+        try {
+            return MessageDigest.getInstance("SHA256").digest(bArr);
+        } catch (NoSuchAlgorithmException e) {
+            throw new RuntimeException("Device doesn't support SHA256 cert checking", e);
+        }
+    }
+
+    private PackageInfoCompat() {
+    }
+
+    private static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        static boolean hasSigningCertificate(PackageManager packageManager, String str, byte[] bArr, int i) {
+            return packageManager.hasSigningCertificate(str, bArr, i);
+        }
+
+        static boolean hasMultipleSigners(SigningInfo signingInfo) {
+            return signingInfo.hasMultipleSigners();
+        }
+
+        static Signature[] getApkContentsSigners(SigningInfo signingInfo) {
+            return signingInfo.getApkContentsSigners();
+        }
+
+        static Signature[] getSigningCertificateHistory(SigningInfo signingInfo) {
+            return signingInfo.getSigningCertificateHistory();
+        }
+
+        static long getLongVersionCode(PackageInfo packageInfo) {
+            return packageInfo.getLongVersionCode();
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/pm/PermissionInfoCompat.java

@@ -0,0 +1,48 @@
+package androidx.core.content.pm;
+
+import android.content.pm.PermissionInfo;
+import android.os.Build;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes.dex */
+public final class PermissionInfoCompat {
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Protection {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ProtectionFlags {
+    }
+
+    private PermissionInfoCompat() {
+    }
+
+    public static int getProtection(PermissionInfo permissionInfo) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.getProtection(permissionInfo);
+        }
+        return permissionInfo.protectionLevel & 15;
+    }
+
+    public static int getProtectionFlags(PermissionInfo permissionInfo) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.getProtectionFlags(permissionInfo);
+        }
+        return permissionInfo.protectionLevel & (-16);
+    }
+
+    static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        static int getProtection(PermissionInfo permissionInfo) {
+            return permissionInfo.getProtection();
+        }
+
+        static int getProtectionFlags(PermissionInfo permissionInfo) {
+            return permissionInfo.getProtectionFlags();
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/pm/ShortcutInfoChangeListener.java

@@ -0,0 +1,21 @@
+package androidx.core.content.pm;
+
+import java.util.List;
+
+/* loaded from: classes.dex */
+public abstract class ShortcutInfoChangeListener {
+    public void onAllShortcutsRemoved() {
+    }
+
+    public void onShortcutAdded(List<ShortcutInfoCompat> list) {
+    }
+
+    public void onShortcutRemoved(List<String> list) {
+    }
+
+    public void onShortcutUpdated(List<ShortcutInfoCompat> list) {
+    }
+
+    public void onShortcutUsageReported(List<String> list) {
+    }
+}

02-Easy5/E5/sources/androidx/core/content/pm/ShortcutInfoCompat.java

@@ -0,0 +1,633 @@
+package androidx.core.content.pm;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.LocusId;
+import android.content.pm.PackageManager;
+import android.content.pm.ShortcutInfo;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.PersistableBundle;
+import android.os.UserHandle;
+import android.text.TextUtils;
+import androidx.core.app.NotificationCompat$Style$$ExternalSyntheticApiModelOutline0;
+import androidx.core.app.Person;
+import androidx.core.content.LocusIdCompat;
+import androidx.core.graphics.drawable.IconCompat;
+import androidx.core.net.UriCompat;
+import androidx.core.util.Preconditions;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+public class ShortcutInfoCompat {
+    private static final String EXTRA_LOCUS_ID = "extraLocusId";
+    private static final String EXTRA_LONG_LIVED = "extraLongLived";
+    private static final String EXTRA_PERSON_ = "extraPerson_";
+    private static final String EXTRA_PERSON_COUNT = "extraPersonCount";
+    private static final String EXTRA_SLICE_URI = "extraSliceUri";
+    public static final int SURFACE_LAUNCHER = 1;
+    ComponentName mActivity;
+    Set<String> mCategories;
+    Context mContext;
+    CharSequence mDisabledMessage;
+    int mDisabledReason;
+    int mExcludedSurfaces;
+    PersistableBundle mExtras;
+    boolean mHasKeyFieldsOnly;
+    IconCompat mIcon;
+    String mId;
+    Intent[] mIntents;
+    boolean mIsAlwaysBadged;
+    boolean mIsCached;
+    boolean mIsDeclaredInManifest;
+    boolean mIsDynamic;
+    boolean mIsEnabled = true;
+    boolean mIsImmutable;
+    boolean mIsLongLived;
+    boolean mIsPinned;
+    CharSequence mLabel;
+    long mLastChangedTimestamp;
+    LocusIdCompat mLocusId;
+    CharSequence mLongLabel;
+    String mPackageName;
+    Person[] mPersons;
+    int mRank;
+    Bundle mTransientExtras;
+    UserHandle mUser;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Surface {
+    }
+
+    public ComponentName getActivity() {
+        return this.mActivity;
+    }
+
+    public Set<String> getCategories() {
+        return this.mCategories;
+    }
+
+    public CharSequence getDisabledMessage() {
+        return this.mDisabledMessage;
+    }
+
+    public int getDisabledReason() {
+        return this.mDisabledReason;
+    }
+
+    public int getExcludedFromSurfaces() {
+        return this.mExcludedSurfaces;
+    }
+
+    public PersistableBundle getExtras() {
+        return this.mExtras;
+    }
+
+    public IconCompat getIcon() {
+        return this.mIcon;
+    }
+
+    public String getId() {
+        return this.mId;
+    }
+
+    public long getLastChangedTimestamp() {
+        return this.mLastChangedTimestamp;
+    }
+
+    public LocusIdCompat getLocusId() {
+        return this.mLocusId;
+    }
+
+    public CharSequence getLongLabel() {
+        return this.mLongLabel;
+    }
+
+    public String getPackage() {
+        return this.mPackageName;
+    }
+
+    public int getRank() {
+        return this.mRank;
+    }
+
+    public CharSequence getShortLabel() {
+        return this.mLabel;
+    }
+
+    public Bundle getTransientExtras() {
+        return this.mTransientExtras;
+    }
+
+    public UserHandle getUserHandle() {
+        return this.mUser;
+    }
+
+    public boolean hasKeyFieldsOnly() {
+        return this.mHasKeyFieldsOnly;
+    }
+
+    public boolean isCached() {
+        return this.mIsCached;
+    }
+
+    public boolean isDeclaredInManifest() {
+        return this.mIsDeclaredInManifest;
+    }
+
+    public boolean isDynamic() {
+        return this.mIsDynamic;
+    }
+
+    public boolean isEnabled() {
+        return this.mIsEnabled;
+    }
+
+    public boolean isExcludedFromSurfaces(int i) {
+        return (i & this.mExcludedSurfaces) != 0;
+    }
+
+    public boolean isImmutable() {
+        return this.mIsImmutable;
+    }
+
+    public boolean isPinned() {
+        return this.mIsPinned;
+    }
+
+    ShortcutInfoCompat() {
+    }
+
+    public ShortcutInfo toShortcutInfo() {
+        ShortcutInfo.Builder shortLabel;
+        ShortcutInfo.Builder intents;
+        ShortcutInfo build;
+        NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$4();
+        shortLabel = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m56m(this.mContext, this.mId).setShortLabel(this.mLabel);
+        intents = shortLabel.setIntents(this.mIntents);
+        IconCompat iconCompat = this.mIcon;
+        if (iconCompat != null) {
+            intents.setIcon(iconCompat.toIcon(this.mContext));
+        }
+        if (!TextUtils.isEmpty(this.mLongLabel)) {
+            intents.setLongLabel(this.mLongLabel);
+        }
+        if (!TextUtils.isEmpty(this.mDisabledMessage)) {
+            intents.setDisabledMessage(this.mDisabledMessage);
+        }
+        ComponentName componentName = this.mActivity;
+        if (componentName != null) {
+            intents.setActivity(componentName);
+        }
+        Set<String> set = this.mCategories;
+        if (set != null) {
+            intents.setCategories(set);
+        }
+        intents.setRank(this.mRank);
+        PersistableBundle persistableBundle = this.mExtras;
+        if (persistableBundle != null) {
+            intents.setExtras(persistableBundle);
+        }
+        if (Build.VERSION.SDK_INT >= 29) {
+            Person[] personArr = this.mPersons;
+            if (personArr != null && personArr.length > 0) {
+                int length = personArr.length;
+                android.app.Person[] personArr2 = new android.app.Person[length];
+                for (int i = 0; i < length; i++) {
+                    personArr2[i] = this.mPersons[i].toAndroidPerson();
+                }
+                intents.setPersons(personArr2);
+            }
+            LocusIdCompat locusIdCompat = this.mLocusId;
+            if (locusIdCompat != null) {
+                intents.setLocusId(locusIdCompat.toLocusId());
+            }
+            intents.setLongLived(this.mIsLongLived);
+        } else {
+            intents.setExtras(buildLegacyExtrasBundle());
+        }
+        build = intents.build();
+        return build;
+    }
+
+    private PersistableBundle buildLegacyExtrasBundle() {
+        if (this.mExtras == null) {
+            this.mExtras = new PersistableBundle();
+        }
+        Person[] personArr = this.mPersons;
+        if (personArr != null && personArr.length > 0) {
+            this.mExtras.putInt(EXTRA_PERSON_COUNT, personArr.length);
+            int i = 0;
+            while (i < this.mPersons.length) {
+                PersistableBundle persistableBundle = this.mExtras;
+                StringBuilder sb = new StringBuilder(EXTRA_PERSON_);
+                int i2 = i + 1;
+                sb.append(i2);
+                persistableBundle.putPersistableBundle(sb.toString(), this.mPersons[i].toPersistableBundle());
+                i = i2;
+            }
+        }
+        LocusIdCompat locusIdCompat = this.mLocusId;
+        if (locusIdCompat != null) {
+            this.mExtras.putString(EXTRA_LOCUS_ID, locusIdCompat.getId());
+        }
+        this.mExtras.putBoolean(EXTRA_LONG_LIVED, this.mIsLongLived);
+        return this.mExtras;
+    }
+
+    Intent addToIntent(Intent intent) {
+        intent.putExtra("android.intent.extra.shortcut.INTENT", this.mIntents[r0.length - 1]).putExtra("android.intent.extra.shortcut.NAME", this.mLabel.toString());
+        if (this.mIcon != null) {
+            Drawable drawable = null;
+            if (this.mIsAlwaysBadged) {
+                PackageManager packageManager = this.mContext.getPackageManager();
+                ComponentName componentName = this.mActivity;
+                if (componentName != null) {
+                    try {
+                        drawable = packageManager.getActivityIcon(componentName);
+                    } catch (PackageManager.NameNotFoundException unused) {
+                    }
+                }
+                if (drawable == null) {
+                    drawable = this.mContext.getApplicationInfo().loadIcon(packageManager);
+                }
+            }
+            this.mIcon.addToShortcutIntent(intent, drawable, this.mContext);
+        }
+        return intent;
+    }
+
+    public Intent getIntent() {
+        return this.mIntents[r0.length - 1];
+    }
+
+    public Intent[] getIntents() {
+        Intent[] intentArr = this.mIntents;
+        return (Intent[]) Arrays.copyOf(intentArr, intentArr.length);
+    }
+
+    static Person[] getPersonsFromExtra(PersistableBundle persistableBundle) {
+        if (persistableBundle == null || !persistableBundle.containsKey(EXTRA_PERSON_COUNT)) {
+            return null;
+        }
+        int i = persistableBundle.getInt(EXTRA_PERSON_COUNT);
+        Person[] personArr = new Person[i];
+        int i2 = 0;
+        while (i2 < i) {
+            StringBuilder sb = new StringBuilder(EXTRA_PERSON_);
+            int i3 = i2 + 1;
+            sb.append(i3);
+            personArr[i2] = Person.fromPersistableBundle(persistableBundle.getPersistableBundle(sb.toString()));
+            i2 = i3;
+        }
+        return personArr;
+    }
+
+    static boolean getLongLivedFromExtra(PersistableBundle persistableBundle) {
+        boolean z;
+        if (persistableBundle == null || !persistableBundle.containsKey(EXTRA_LONG_LIVED)) {
+            return false;
+        }
+        z = persistableBundle.getBoolean(EXTRA_LONG_LIVED);
+        return z;
+    }
+
+    static List<ShortcutInfoCompat> fromShortcuts(Context context, List<ShortcutInfo> list) {
+        ArrayList arrayList = new ArrayList(list.size());
+        Iterator<ShortcutInfo> it = list.iterator();
+        while (it.hasNext()) {
+            arrayList.add(new Builder(context, NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m57m((Object) it.next())).build());
+        }
+        return arrayList;
+    }
+
+    static LocusIdCompat getLocusId(ShortcutInfo shortcutInfo) {
+        PersistableBundle extras;
+        LocusId locusId;
+        LocusId locusId2;
+        if (Build.VERSION.SDK_INT >= 29) {
+            locusId = shortcutInfo.getLocusId();
+            if (locusId == null) {
+                return null;
+            }
+            locusId2 = shortcutInfo.getLocusId();
+            return LocusIdCompat.toLocusIdCompat(locusId2);
+        }
+        extras = shortcutInfo.getExtras();
+        return getLocusIdFromExtra(extras);
+    }
+
+    private static LocusIdCompat getLocusIdFromExtra(PersistableBundle persistableBundle) {
+        String string;
+        if (persistableBundle == null || (string = persistableBundle.getString(EXTRA_LOCUS_ID)) == null) {
+            return null;
+        }
+        return new LocusIdCompat(string);
+    }
+
+    public static class Builder {
+        private Map<String, Map<String, List<String>>> mCapabilityBindingParams;
+        private Set<String> mCapabilityBindings;
+        private final ShortcutInfoCompat mInfo;
+        private boolean mIsConversation;
+        private Uri mSliceUri;
+
+        public Builder setIsConversation() {
+            this.mIsConversation = true;
+            return this;
+        }
+
+        public Builder setSliceUri(Uri uri) {
+            this.mSliceUri = uri;
+            return this;
+        }
+
+        public Builder(Context context, String str) {
+            ShortcutInfoCompat shortcutInfoCompat = new ShortcutInfoCompat();
+            this.mInfo = shortcutInfoCompat;
+            shortcutInfoCompat.mContext = context;
+            shortcutInfoCompat.mId = str;
+        }
+
+        public Builder(ShortcutInfoCompat shortcutInfoCompat) {
+            ShortcutInfoCompat shortcutInfoCompat2 = new ShortcutInfoCompat();
+            this.mInfo = shortcutInfoCompat2;
+            shortcutInfoCompat2.mContext = shortcutInfoCompat.mContext;
+            shortcutInfoCompat2.mId = shortcutInfoCompat.mId;
+            shortcutInfoCompat2.mPackageName = shortcutInfoCompat.mPackageName;
+            shortcutInfoCompat2.mIntents = (Intent[]) Arrays.copyOf(shortcutInfoCompat.mIntents, shortcutInfoCompat.mIntents.length);
+            shortcutInfoCompat2.mActivity = shortcutInfoCompat.mActivity;
+            shortcutInfoCompat2.mLabel = shortcutInfoCompat.mLabel;
+            shortcutInfoCompat2.mLongLabel = shortcutInfoCompat.mLongLabel;
+            shortcutInfoCompat2.mDisabledMessage = shortcutInfoCompat.mDisabledMessage;
+            shortcutInfoCompat2.mDisabledReason = shortcutInfoCompat.mDisabledReason;
+            shortcutInfoCompat2.mIcon = shortcutInfoCompat.mIcon;
+            shortcutInfoCompat2.mIsAlwaysBadged = shortcutInfoCompat.mIsAlwaysBadged;
+            shortcutInfoCompat2.mUser = shortcutInfoCompat.mUser;
+            shortcutInfoCompat2.mLastChangedTimestamp = shortcutInfoCompat.mLastChangedTimestamp;
+            shortcutInfoCompat2.mIsCached = shortcutInfoCompat.mIsCached;
+            shortcutInfoCompat2.mIsDynamic = shortcutInfoCompat.mIsDynamic;
+            shortcutInfoCompat2.mIsPinned = shortcutInfoCompat.mIsPinned;
+            shortcutInfoCompat2.mIsDeclaredInManifest = shortcutInfoCompat.mIsDeclaredInManifest;
+            shortcutInfoCompat2.mIsImmutable = shortcutInfoCompat.mIsImmutable;
+            shortcutInfoCompat2.mIsEnabled = shortcutInfoCompat.mIsEnabled;
+            shortcutInfoCompat2.mLocusId = shortcutInfoCompat.mLocusId;
+            shortcutInfoCompat2.mIsLongLived = shortcutInfoCompat.mIsLongLived;
+            shortcutInfoCompat2.mHasKeyFieldsOnly = shortcutInfoCompat.mHasKeyFieldsOnly;
+            shortcutInfoCompat2.mRank = shortcutInfoCompat.mRank;
+            if (shortcutInfoCompat.mPersons != null) {
+                shortcutInfoCompat2.mPersons = (Person[]) Arrays.copyOf(shortcutInfoCompat.mPersons, shortcutInfoCompat.mPersons.length);
+            }
+            if (shortcutInfoCompat.mCategories != null) {
+                shortcutInfoCompat2.mCategories = new HashSet(shortcutInfoCompat.mCategories);
+            }
+            if (shortcutInfoCompat.mExtras != null) {
+                shortcutInfoCompat2.mExtras = shortcutInfoCompat.mExtras;
+            }
+            shortcutInfoCompat2.mExcludedSurfaces = shortcutInfoCompat.mExcludedSurfaces;
+        }
+
+        public Builder(Context context, ShortcutInfo shortcutInfo) {
+            String id;
+            String str;
+            Intent[] intents;
+            ComponentName activity;
+            CharSequence shortLabel;
+            CharSequence longLabel;
+            CharSequence disabledMessage;
+            boolean isEnabled;
+            Set<String> categories;
+            PersistableBundle extras;
+            UserHandle userHandle;
+            long lastChangedTimestamp;
+            boolean isDynamic;
+            boolean isPinned;
+            boolean isDeclaredInManifest;
+            boolean isImmutable;
+            boolean isEnabled2;
+            boolean hasKeyFieldsOnly;
+            int rank;
+            PersistableBundle extras2;
+            boolean isCached;
+            int disabledReason;
+            ShortcutInfoCompat shortcutInfoCompat = new ShortcutInfoCompat();
+            this.mInfo = shortcutInfoCompat;
+            shortcutInfoCompat.mContext = context;
+            id = shortcutInfo.getId();
+            shortcutInfoCompat.mId = id;
+            str = shortcutInfo.getPackage();
+            shortcutInfoCompat.mPackageName = str;
+            intents = shortcutInfo.getIntents();
+            shortcutInfoCompat.mIntents = (Intent[]) Arrays.copyOf(intents, intents.length);
+            activity = shortcutInfo.getActivity();
+            shortcutInfoCompat.mActivity = activity;
+            shortLabel = shortcutInfo.getShortLabel();
+            shortcutInfoCompat.mLabel = shortLabel;
+            longLabel = shortcutInfo.getLongLabel();
+            shortcutInfoCompat.mLongLabel = longLabel;
+            disabledMessage = shortcutInfo.getDisabledMessage();
+            shortcutInfoCompat.mDisabledMessage = disabledMessage;
+            if (Build.VERSION.SDK_INT >= 28) {
+                disabledReason = shortcutInfo.getDisabledReason();
+                shortcutInfoCompat.mDisabledReason = disabledReason;
+            } else {
+                isEnabled = shortcutInfo.isEnabled();
+                shortcutInfoCompat.mDisabledReason = isEnabled ? 0 : 3;
+            }
+            categories = shortcutInfo.getCategories();
+            shortcutInfoCompat.mCategories = categories;
+            extras = shortcutInfo.getExtras();
+            shortcutInfoCompat.mPersons = ShortcutInfoCompat.getPersonsFromExtra(extras);
+            userHandle = shortcutInfo.getUserHandle();
+            shortcutInfoCompat.mUser = userHandle;
+            lastChangedTimestamp = shortcutInfo.getLastChangedTimestamp();
+            shortcutInfoCompat.mLastChangedTimestamp = lastChangedTimestamp;
+            if (Build.VERSION.SDK_INT >= 30) {
+                isCached = shortcutInfo.isCached();
+                shortcutInfoCompat.mIsCached = isCached;
+            }
+            isDynamic = shortcutInfo.isDynamic();
+            shortcutInfoCompat.mIsDynamic = isDynamic;
+            isPinned = shortcutInfo.isPinned();
+            shortcutInfoCompat.mIsPinned = isPinned;
+            isDeclaredInManifest = shortcutInfo.isDeclaredInManifest();
+            shortcutInfoCompat.mIsDeclaredInManifest = isDeclaredInManifest;
+            isImmutable = shortcutInfo.isImmutable();
+            shortcutInfoCompat.mIsImmutable = isImmutable;
+            isEnabled2 = shortcutInfo.isEnabled();
+            shortcutInfoCompat.mIsEnabled = isEnabled2;
+            hasKeyFieldsOnly = shortcutInfo.hasKeyFieldsOnly();
+            shortcutInfoCompat.mHasKeyFieldsOnly = hasKeyFieldsOnly;
+            shortcutInfoCompat.mLocusId = ShortcutInfoCompat.getLocusId(shortcutInfo);
+            rank = shortcutInfo.getRank();
+            shortcutInfoCompat.mRank = rank;
+            extras2 = shortcutInfo.getExtras();
+            shortcutInfoCompat.mExtras = extras2;
+        }
+
+        public Builder setShortLabel(CharSequence charSequence) {
+            this.mInfo.mLabel = charSequence;
+            return this;
+        }
+
+        public Builder setLongLabel(CharSequence charSequence) {
+            this.mInfo.mLongLabel = charSequence;
+            return this;
+        }
+
+        public Builder setDisabledMessage(CharSequence charSequence) {
+            this.mInfo.mDisabledMessage = charSequence;
+            return this;
+        }
+
+        public Builder setIntent(Intent intent) {
+            return setIntents(new Intent[]{intent});
+        }
+
+        public Builder setIntents(Intent[] intentArr) {
+            this.mInfo.mIntents = intentArr;
+            return this;
+        }
+
+        public Builder setIcon(IconCompat iconCompat) {
+            this.mInfo.mIcon = iconCompat;
+            return this;
+        }
+
+        public Builder setLocusId(LocusIdCompat locusIdCompat) {
+            this.mInfo.mLocusId = locusIdCompat;
+            return this;
+        }
+
+        public Builder setActivity(ComponentName componentName) {
+            this.mInfo.mActivity = componentName;
+            return this;
+        }
+
+        public Builder setAlwaysBadged() {
+            this.mInfo.mIsAlwaysBadged = true;
+            return this;
+        }
+
+        public Builder setPerson(Person person) {
+            return setPersons(new Person[]{person});
+        }
+
+        public Builder setPersons(Person[] personArr) {
+            this.mInfo.mPersons = personArr;
+            return this;
+        }
+
+        public Builder setCategories(Set<String> set) {
+            this.mInfo.mCategories = set;
+            return this;
+        }
+
+        @Deprecated
+        public Builder setLongLived() {
+            this.mInfo.mIsLongLived = true;
+            return this;
+        }
+
+        public Builder setLongLived(boolean z) {
+            this.mInfo.mIsLongLived = z;
+            return this;
+        }
+
+        public Builder setExcludedFromSurfaces(int i) {
+            this.mInfo.mExcludedSurfaces = i;
+            return this;
+        }
+
+        public Builder setRank(int i) {
+            this.mInfo.mRank = i;
+            return this;
+        }
+
+        public Builder setExtras(PersistableBundle persistableBundle) {
+            this.mInfo.mExtras = persistableBundle;
+            return this;
+        }
+
+        public Builder setTransientExtras(Bundle bundle) {
+            this.mInfo.mTransientExtras = (Bundle) Preconditions.checkNotNull(bundle);
+            return this;
+        }
+
+        public Builder addCapabilityBinding(String str) {
+            if (this.mCapabilityBindings == null) {
+                this.mCapabilityBindings = new HashSet();
+            }
+            this.mCapabilityBindings.add(str);
+            return this;
+        }
+
+        public Builder addCapabilityBinding(String str, String str2, List<String> list) {
+            addCapabilityBinding(str);
+            if (!list.isEmpty()) {
+                if (this.mCapabilityBindingParams == null) {
+                    this.mCapabilityBindingParams = new HashMap();
+                }
+                if (this.mCapabilityBindingParams.get(str) == null) {
+                    this.mCapabilityBindingParams.put(str, new HashMap());
+                }
+                this.mCapabilityBindingParams.get(str).put(str2, list);
+            }
+            return this;
+        }
+
+        public ShortcutInfoCompat build() {
+            if (TextUtils.isEmpty(this.mInfo.mLabel)) {
+                throw new IllegalArgumentException("Shortcut must have a non-empty label");
+            }
+            if (this.mInfo.mIntents == null || this.mInfo.mIntents.length == 0) {
+                throw new IllegalArgumentException("Shortcut must have an intent");
+            }
+            if (this.mIsConversation) {
+                if (this.mInfo.mLocusId == null) {
+                    ShortcutInfoCompat shortcutInfoCompat = this.mInfo;
+                    shortcutInfoCompat.mLocusId = new LocusIdCompat(shortcutInfoCompat.mId);
+                }
+                this.mInfo.mIsLongLived = true;
+            }
+            if (this.mCapabilityBindings != null) {
+                if (this.mInfo.mCategories == null) {
+                    this.mInfo.mCategories = new HashSet();
+                }
+                this.mInfo.mCategories.addAll(this.mCapabilityBindings);
+            }
+            if (this.mCapabilityBindingParams != null) {
+                if (this.mInfo.mExtras == null) {
+                    this.mInfo.mExtras = new PersistableBundle();
+                }
+                for (String str : this.mCapabilityBindingParams.keySet()) {
+                    Map<String, List<String>> map = this.mCapabilityBindingParams.get(str);
+                    this.mInfo.mExtras.putStringArray(str, (String[]) map.keySet().toArray(new String[0]));
+                    for (String str2 : map.keySet()) {
+                        List<String> list = map.get(str2);
+                        this.mInfo.mExtras.putStringArray(str + "/" + str2, list == null ? new String[0] : (String[]) list.toArray(new String[0]));
+                    }
+                }
+            }
+            if (this.mSliceUri != null) {
+                if (this.mInfo.mExtras == null) {
+                    this.mInfo.mExtras = new PersistableBundle();
+                }
+                this.mInfo.mExtras.putString(ShortcutInfoCompat.EXTRA_SLICE_URI, UriCompat.toSafeString(this.mSliceUri));
+            }
+            return this.mInfo;
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/pm/ShortcutInfoCompatSaver.java

@@ -0,0 +1,46 @@
+package androidx.core.content.pm;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public abstract class ShortcutInfoCompatSaver<T> {
+    public abstract T addShortcuts(List<ShortcutInfoCompat> list);
+
+    public abstract T removeAllShortcuts();
+
+    public abstract T removeShortcuts(List<String> list);
+
+    public List<ShortcutInfoCompat> getShortcuts() throws Exception {
+        return new ArrayList();
+    }
+
+    public static class NoopImpl extends ShortcutInfoCompatSaver<Void> {
+        @Override // androidx.core.content.pm.ShortcutInfoCompatSaver
+        /* renamed from: addShortcuts, reason: avoid collision after fix types in other method */
+        public Void addShortcuts2(List<ShortcutInfoCompat> list) {
+            return null;
+        }
+
+        @Override // androidx.core.content.pm.ShortcutInfoCompatSaver
+        public Void removeAllShortcuts() {
+            return null;
+        }
+
+        @Override // androidx.core.content.pm.ShortcutInfoCompatSaver
+        /* renamed from: removeShortcuts, reason: avoid collision after fix types in other method */
+        public Void removeShortcuts2(List<String> list) {
+            return null;
+        }
+
+        @Override // androidx.core.content.pm.ShortcutInfoCompatSaver
+        public /* bridge */ /* synthetic */ Void addShortcuts(List list) {
+            return addShortcuts2((List<ShortcutInfoCompat>) list);
+        }
+
+        @Override // androidx.core.content.pm.ShortcutInfoCompatSaver
+        public /* bridge */ /* synthetic */ Void removeShortcuts(List list) {
+            return removeShortcuts2((List<String>) list);
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/pm/ShortcutManagerCompat.java

@@ -0,0 +1,599 @@
+package androidx.core.content.pm;
+
+import android.app.ActivityManager;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentSender;
+import android.content.pm.ActivityInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.content.pm.ShortcutInfo;
+import android.content.pm.ShortcutManager;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.os.Build;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.util.DisplayMetrics;
+import androidx.core.app.NotificationCompat$Style$$ExternalSyntheticApiModelOutline0;
+import androidx.core.content.ContextCompat;
+import androidx.core.content.pm.ShortcutInfoCompat;
+import androidx.core.content.pm.ShortcutInfoCompatSaver;
+import androidx.core.graphics.drawable.IconCompat;
+import androidx.core.util.Preconditions;
+import java.io.InputStream;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+
+/* loaded from: classes.dex */
+public class ShortcutManagerCompat {
+    static final String ACTION_INSTALL_SHORTCUT = "com.android.launcher.action.INSTALL_SHORTCUT";
+    private static final int DEFAULT_MAX_ICON_DIMENSION_DP = 96;
+    private static final int DEFAULT_MAX_ICON_DIMENSION_LOWRAM_DP = 48;
+    public static final String EXTRA_SHORTCUT_ID = "android.intent.extra.shortcut.ID";
+    public static final int FLAG_MATCH_CACHED = 8;
+    public static final int FLAG_MATCH_DYNAMIC = 2;
+    public static final int FLAG_MATCH_MANIFEST = 1;
+    public static final int FLAG_MATCH_PINNED = 4;
+    static final String INSTALL_SHORTCUT_PERMISSION = "com.android.launcher.permission.INSTALL_SHORTCUT";
+    private static final String SHORTCUT_LISTENER_INTENT_FILTER_ACTION = "androidx.core.content.pm.SHORTCUT_LISTENER";
+    private static final String SHORTCUT_LISTENER_META_DATA_KEY = "androidx.core.content.pm.shortcut_listener_impl";
+    private static volatile List<ShortcutInfoChangeListener> sShortcutInfoChangeListeners;
+    private static volatile ShortcutInfoCompatSaver<?> sShortcutInfoCompatSaver;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ShortcutMatchFlags {
+    }
+
+    static List<ShortcutInfoChangeListener> getShortcutInfoChangeListeners() {
+        return sShortcutInfoChangeListeners;
+    }
+
+    static void setShortcutInfoChangeListeners(List<ShortcutInfoChangeListener> list) {
+        sShortcutInfoChangeListeners = list;
+    }
+
+    static void setShortcutInfoCompatSaver(ShortcutInfoCompatSaver<Void> shortcutInfoCompatSaver) {
+        sShortcutInfoCompatSaver = shortcutInfoCompatSaver;
+    }
+
+    private ShortcutManagerCompat() {
+    }
+
+    public static boolean isRequestPinShortcutSupported(Context context) {
+        Object systemService;
+        boolean isRequestPinShortcutSupported;
+        if (Build.VERSION.SDK_INT >= 26) {
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            isRequestPinShortcutSupported = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).isRequestPinShortcutSupported();
+            return isRequestPinShortcutSupported;
+        }
+        if (ContextCompat.checkSelfPermission(context, INSTALL_SHORTCUT_PERMISSION) != 0) {
+            return false;
+        }
+        Iterator<ResolveInfo> it = context.getPackageManager().queryBroadcastReceivers(new Intent(ACTION_INSTALL_SHORTCUT), 0).iterator();
+        while (it.hasNext()) {
+            String str = it.next().activityInfo.permission;
+            if (TextUtils.isEmpty(str) || INSTALL_SHORTCUT_PERMISSION.equals(str)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean requestPinShortcut(Context context, ShortcutInfoCompat shortcutInfoCompat, final IntentSender intentSender) {
+        Object systemService;
+        boolean requestPinShortcut;
+        if (Build.VERSION.SDK_INT <= 31 && shortcutInfoCompat.isExcludedFromSurfaces(1)) {
+            return false;
+        }
+        if (Build.VERSION.SDK_INT >= 26) {
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            requestPinShortcut = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).requestPinShortcut(shortcutInfoCompat.toShortcutInfo(), intentSender);
+            return requestPinShortcut;
+        }
+        if (!isRequestPinShortcutSupported(context)) {
+            return false;
+        }
+        Intent addToIntent = shortcutInfoCompat.addToIntent(new Intent(ACTION_INSTALL_SHORTCUT));
+        if (intentSender == null) {
+            context.sendBroadcast(addToIntent);
+            return true;
+        }
+        context.sendOrderedBroadcast(addToIntent, null, new BroadcastReceiver() { // from class: androidx.core.content.pm.ShortcutManagerCompat.1
+            @Override // android.content.BroadcastReceiver
+            public void onReceive(Context context2, Intent intent) {
+                try {
+                    intentSender.sendIntent(context2, 0, null, null, null);
+                } catch (IntentSender.SendIntentException unused) {
+                }
+            }
+        }, null, -1, null, null);
+        return true;
+    }
+
+    public static Intent createShortcutResultIntent(Context context, ShortcutInfoCompat shortcutInfoCompat) {
+        Intent intent;
+        Object systemService;
+        if (Build.VERSION.SDK_INT >= 26) {
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            intent = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).createShortcutResultIntent(shortcutInfoCompat.toShortcutInfo());
+        } else {
+            intent = null;
+        }
+        if (intent == null) {
+            intent = new Intent();
+        }
+        return shortcutInfoCompat.addToIntent(intent);
+    }
+
+    public static List<ShortcutInfoCompat> getShortcuts(Context context, int i) {
+        Object systemService;
+        List pinnedShortcuts;
+        List dynamicShortcuts;
+        List manifestShortcuts;
+        Object systemService2;
+        List shortcuts;
+        if (Build.VERSION.SDK_INT >= 30) {
+            systemService2 = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            shortcuts = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService2).getShortcuts(i);
+            return ShortcutInfoCompat.fromShortcuts(context, shortcuts);
+        }
+        if (Build.VERSION.SDK_INT >= 25) {
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            ShortcutManager m58m = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService);
+            ArrayList arrayList = new ArrayList();
+            if ((i & 1) != 0) {
+                manifestShortcuts = m58m.getManifestShortcuts();
+                arrayList.addAll(manifestShortcuts);
+            }
+            if ((i & 2) != 0) {
+                dynamicShortcuts = m58m.getDynamicShortcuts();
+                arrayList.addAll(dynamicShortcuts);
+            }
+            if ((i & 4) != 0) {
+                pinnedShortcuts = m58m.getPinnedShortcuts();
+                arrayList.addAll(pinnedShortcuts);
+            }
+            return ShortcutInfoCompat.fromShortcuts(context, arrayList);
+        }
+        if ((i & 2) != 0) {
+            try {
+                return getShortcutInfoSaverInstance(context).getShortcuts();
+            } catch (Exception unused) {
+            }
+        }
+        return Collections.emptyList();
+    }
+
+    public static boolean addDynamicShortcuts(Context context, List<ShortcutInfoCompat> list) {
+        Object systemService;
+        boolean addDynamicShortcuts;
+        List<ShortcutInfoCompat> removeShortcutsExcludedFromSurface = removeShortcutsExcludedFromSurface(list, 1);
+        if (Build.VERSION.SDK_INT <= 29) {
+            convertUriIconsToBitmapIcons(context, removeShortcutsExcludedFromSurface);
+        }
+        if (Build.VERSION.SDK_INT >= 25) {
+            ArrayList arrayList = new ArrayList();
+            Iterator<ShortcutInfoCompat> it = removeShortcutsExcludedFromSurface.iterator();
+            while (it.hasNext()) {
+                arrayList.add(it.next().toShortcutInfo());
+            }
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            addDynamicShortcuts = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).addDynamicShortcuts(arrayList);
+            if (!addDynamicShortcuts) {
+                return false;
+            }
+        }
+        getShortcutInfoSaverInstance(context).addShortcuts(removeShortcutsExcludedFromSurface);
+        Iterator<ShortcutInfoChangeListener> it2 = getShortcutInfoListeners(context).iterator();
+        while (it2.hasNext()) {
+            it2.next().onShortcutAdded(list);
+        }
+        return true;
+    }
+
+    public static int getMaxShortcutCountPerActivity(Context context) {
+        Object systemService;
+        int maxShortcutCountPerActivity;
+        Preconditions.checkNotNull(context);
+        if (Build.VERSION.SDK_INT < 25) {
+            return 5;
+        }
+        systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+        maxShortcutCountPerActivity = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).getMaxShortcutCountPerActivity();
+        return maxShortcutCountPerActivity;
+    }
+
+    public static boolean isRateLimitingActive(Context context) {
+        Object systemService;
+        boolean isRateLimitingActive;
+        Preconditions.checkNotNull(context);
+        if (Build.VERSION.SDK_INT < 25) {
+            return getShortcuts(context, 3).size() == getMaxShortcutCountPerActivity(context);
+        }
+        systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+        isRateLimitingActive = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).isRateLimitingActive();
+        return isRateLimitingActive;
+    }
+
+    public static int getIconMaxWidth(Context context) {
+        Object systemService;
+        int iconMaxWidth;
+        Preconditions.checkNotNull(context);
+        if (Build.VERSION.SDK_INT >= 25) {
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            iconMaxWidth = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).getIconMaxWidth();
+            return iconMaxWidth;
+        }
+        return getIconDimensionInternal(context, true);
+    }
+
+    public static int getIconMaxHeight(Context context) {
+        Object systemService;
+        int iconMaxHeight;
+        Preconditions.checkNotNull(context);
+        if (Build.VERSION.SDK_INT >= 25) {
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            iconMaxHeight = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).getIconMaxHeight();
+            return iconMaxHeight;
+        }
+        return getIconDimensionInternal(context, false);
+    }
+
+    public static void reportShortcutUsed(Context context, String str) {
+        Object systemService;
+        Preconditions.checkNotNull(context);
+        Preconditions.checkNotNull(str);
+        if (Build.VERSION.SDK_INT >= 25) {
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).reportShortcutUsed(str);
+        }
+        Iterator<ShortcutInfoChangeListener> it = getShortcutInfoListeners(context).iterator();
+        while (it.hasNext()) {
+            it.next().onShortcutUsageReported(Collections.singletonList(str));
+        }
+    }
+
+    public static boolean setDynamicShortcuts(Context context, List<ShortcutInfoCompat> list) {
+        Object systemService;
+        boolean dynamicShortcuts;
+        Preconditions.checkNotNull(context);
+        Preconditions.checkNotNull(list);
+        List<ShortcutInfoCompat> removeShortcutsExcludedFromSurface = removeShortcutsExcludedFromSurface(list, 1);
+        if (Build.VERSION.SDK_INT >= 25) {
+            ArrayList arrayList = new ArrayList(removeShortcutsExcludedFromSurface.size());
+            Iterator<ShortcutInfoCompat> it = removeShortcutsExcludedFromSurface.iterator();
+            while (it.hasNext()) {
+                arrayList.add(it.next().toShortcutInfo());
+            }
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            dynamicShortcuts = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).setDynamicShortcuts(arrayList);
+            if (!dynamicShortcuts) {
+                return false;
+            }
+        }
+        getShortcutInfoSaverInstance(context).removeAllShortcuts();
+        getShortcutInfoSaverInstance(context).addShortcuts(removeShortcutsExcludedFromSurface);
+        for (ShortcutInfoChangeListener shortcutInfoChangeListener : getShortcutInfoListeners(context)) {
+            shortcutInfoChangeListener.onAllShortcutsRemoved();
+            shortcutInfoChangeListener.onShortcutAdded(list);
+        }
+        return true;
+    }
+
+    public static List<ShortcutInfoCompat> getDynamicShortcuts(Context context) {
+        Object systemService;
+        List dynamicShortcuts;
+        if (Build.VERSION.SDK_INT >= 25) {
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            dynamicShortcuts = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).getDynamicShortcuts();
+            ArrayList arrayList = new ArrayList(dynamicShortcuts.size());
+            Iterator it = dynamicShortcuts.iterator();
+            while (it.hasNext()) {
+                arrayList.add(new ShortcutInfoCompat.Builder(context, NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m57m(it.next())).build());
+            }
+            return arrayList;
+        }
+        try {
+            return getShortcutInfoSaverInstance(context).getShortcuts();
+        } catch (Exception unused) {
+            return new ArrayList();
+        }
+    }
+
+    public static boolean updateShortcuts(Context context, List<ShortcutInfoCompat> list) {
+        Object systemService;
+        boolean updateShortcuts;
+        List<ShortcutInfoCompat> removeShortcutsExcludedFromSurface = removeShortcutsExcludedFromSurface(list, 1);
+        if (Build.VERSION.SDK_INT <= 29) {
+            convertUriIconsToBitmapIcons(context, removeShortcutsExcludedFromSurface);
+        }
+        if (Build.VERSION.SDK_INT >= 25) {
+            ArrayList arrayList = new ArrayList();
+            Iterator<ShortcutInfoCompat> it = removeShortcutsExcludedFromSurface.iterator();
+            while (it.hasNext()) {
+                arrayList.add(it.next().toShortcutInfo());
+            }
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            updateShortcuts = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).updateShortcuts(arrayList);
+            if (!updateShortcuts) {
+                return false;
+            }
+        }
+        getShortcutInfoSaverInstance(context).addShortcuts(removeShortcutsExcludedFromSurface);
+        Iterator<ShortcutInfoChangeListener> it2 = getShortcutInfoListeners(context).iterator();
+        while (it2.hasNext()) {
+            it2.next().onShortcutUpdated(list);
+        }
+        return true;
+    }
+
+    static boolean convertUriIconToBitmapIcon(Context context, ShortcutInfoCompat shortcutInfoCompat) {
+        Bitmap decodeStream;
+        IconCompat createWithBitmap;
+        if (shortcutInfoCompat.mIcon == null) {
+            return false;
+        }
+        int i = shortcutInfoCompat.mIcon.mType;
+        if (i != 6 && i != 4) {
+            return true;
+        }
+        InputStream uriInputStream = shortcutInfoCompat.mIcon.getUriInputStream(context);
+        if (uriInputStream == null || (decodeStream = BitmapFactory.decodeStream(uriInputStream)) == null) {
+            return false;
+        }
+        if (i == 6) {
+            createWithBitmap = IconCompat.createWithAdaptiveBitmap(decodeStream);
+        } else {
+            createWithBitmap = IconCompat.createWithBitmap(decodeStream);
+        }
+        shortcutInfoCompat.mIcon = createWithBitmap;
+        return true;
+    }
+
+    static void convertUriIconsToBitmapIcons(Context context, List<ShortcutInfoCompat> list) {
+        for (ShortcutInfoCompat shortcutInfoCompat : new ArrayList(list)) {
+            if (!convertUriIconToBitmapIcon(context, shortcutInfoCompat)) {
+                list.remove(shortcutInfoCompat);
+            }
+        }
+    }
+
+    public static void disableShortcuts(Context context, List<String> list, CharSequence charSequence) {
+        Object systemService;
+        if (Build.VERSION.SDK_INT >= 25) {
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).disableShortcuts(list, charSequence);
+        }
+        getShortcutInfoSaverInstance(context).removeShortcuts(list);
+        Iterator<ShortcutInfoChangeListener> it = getShortcutInfoListeners(context).iterator();
+        while (it.hasNext()) {
+            it.next().onShortcutRemoved(list);
+        }
+    }
+
+    public static void enableShortcuts(Context context, List<ShortcutInfoCompat> list) {
+        Object systemService;
+        List<ShortcutInfoCompat> removeShortcutsExcludedFromSurface = removeShortcutsExcludedFromSurface(list, 1);
+        if (Build.VERSION.SDK_INT >= 25) {
+            ArrayList arrayList = new ArrayList(list.size());
+            Iterator<ShortcutInfoCompat> it = removeShortcutsExcludedFromSurface.iterator();
+            while (it.hasNext()) {
+                arrayList.add(it.next().mId);
+            }
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).enableShortcuts(arrayList);
+        }
+        getShortcutInfoSaverInstance(context).addShortcuts(removeShortcutsExcludedFromSurface);
+        Iterator<ShortcutInfoChangeListener> it2 = getShortcutInfoListeners(context).iterator();
+        while (it2.hasNext()) {
+            it2.next().onShortcutAdded(list);
+        }
+    }
+
+    public static void removeDynamicShortcuts(Context context, List<String> list) {
+        Object systemService;
+        if (Build.VERSION.SDK_INT >= 25) {
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).removeDynamicShortcuts(list);
+        }
+        getShortcutInfoSaverInstance(context).removeShortcuts(list);
+        Iterator<ShortcutInfoChangeListener> it = getShortcutInfoListeners(context).iterator();
+        while (it.hasNext()) {
+            it.next().onShortcutRemoved(list);
+        }
+    }
+
+    public static void removeAllDynamicShortcuts(Context context) {
+        Object systemService;
+        if (Build.VERSION.SDK_INT >= 25) {
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).removeAllDynamicShortcuts();
+        }
+        getShortcutInfoSaverInstance(context).removeAllShortcuts();
+        Iterator<ShortcutInfoChangeListener> it = getShortcutInfoListeners(context).iterator();
+        while (it.hasNext()) {
+            it.next().onAllShortcutsRemoved();
+        }
+    }
+
+    public static void removeLongLivedShortcuts(Context context, List<String> list) {
+        Object systemService;
+        if (Build.VERSION.SDK_INT < 30) {
+            removeDynamicShortcuts(context, list);
+            return;
+        }
+        systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+        NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService).removeLongLivedShortcuts(list);
+        getShortcutInfoSaverInstance(context).removeShortcuts(list);
+        Iterator<ShortcutInfoChangeListener> it = getShortcutInfoListeners(context).iterator();
+        while (it.hasNext()) {
+            it.next().onShortcutRemoved(list);
+        }
+    }
+
+    public static boolean pushDynamicShortcut(Context context, ShortcutInfoCompat shortcutInfoCompat) {
+        Object systemService;
+        boolean isRateLimitingActive;
+        List dynamicShortcuts;
+        Object systemService2;
+        Preconditions.checkNotNull(context);
+        Preconditions.checkNotNull(shortcutInfoCompat);
+        if (Build.VERSION.SDK_INT <= 31 && shortcutInfoCompat.isExcludedFromSurfaces(1)) {
+            Iterator<ShortcutInfoChangeListener> it = getShortcutInfoListeners(context).iterator();
+            while (it.hasNext()) {
+                it.next().onShortcutAdded(Collections.singletonList(shortcutInfoCompat));
+            }
+            return true;
+        }
+        int maxShortcutCountPerActivity = getMaxShortcutCountPerActivity(context);
+        if (maxShortcutCountPerActivity == 0) {
+            return false;
+        }
+        if (Build.VERSION.SDK_INT <= 29) {
+            convertUriIconToBitmapIcon(context, shortcutInfoCompat);
+        }
+        if (Build.VERSION.SDK_INT >= 30) {
+            systemService2 = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService2).pushDynamicShortcut(shortcutInfoCompat.toShortcutInfo());
+        } else if (Build.VERSION.SDK_INT >= 25) {
+            systemService = context.getSystemService((Class<Object>) NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m$3());
+            ShortcutManager m58m = NotificationCompat$Style$$ExternalSyntheticApiModelOutline0.m58m(systemService);
+            isRateLimitingActive = m58m.isRateLimitingActive();
+            if (isRateLimitingActive) {
+                return false;
+            }
+            dynamicShortcuts = m58m.getDynamicShortcuts();
+            if (dynamicShortcuts.size() >= maxShortcutCountPerActivity) {
+                m58m.removeDynamicShortcuts(Arrays.asList(Api25Impl.getShortcutInfoWithLowestRank(dynamicShortcuts)));
+            }
+            m58m.addDynamicShortcuts(Arrays.asList(shortcutInfoCompat.toShortcutInfo()));
+        }
+        ShortcutInfoCompatSaver<?> shortcutInfoSaverInstance = getShortcutInfoSaverInstance(context);
+        try {
+            List<ShortcutInfoCompat> shortcuts = shortcutInfoSaverInstance.getShortcuts();
+            if (shortcuts.size() >= maxShortcutCountPerActivity) {
+                shortcutInfoSaverInstance.removeShortcuts(Arrays.asList(getShortcutInfoCompatWithLowestRank(shortcuts)));
+            }
+            shortcutInfoSaverInstance.addShortcuts(Arrays.asList(shortcutInfoCompat));
+            Iterator<ShortcutInfoChangeListener> it2 = getShortcutInfoListeners(context).iterator();
+            while (it2.hasNext()) {
+                it2.next().onShortcutAdded(Collections.singletonList(shortcutInfoCompat));
+            }
+            reportShortcutUsed(context, shortcutInfoCompat.getId());
+            return true;
+        } catch (Exception unused) {
+            Iterator<ShortcutInfoChangeListener> it3 = getShortcutInfoListeners(context).iterator();
+            while (it3.hasNext()) {
+                it3.next().onShortcutAdded(Collections.singletonList(shortcutInfoCompat));
+            }
+            reportShortcutUsed(context, shortcutInfoCompat.getId());
+            return false;
+        } catch (Throwable th) {
+            Iterator<ShortcutInfoChangeListener> it4 = getShortcutInfoListeners(context).iterator();
+            while (it4.hasNext()) {
+                it4.next().onShortcutAdded(Collections.singletonList(shortcutInfoCompat));
+            }
+            reportShortcutUsed(context, shortcutInfoCompat.getId());
+            throw th;
+        }
+    }
+
+    private static String getShortcutInfoCompatWithLowestRank(List<ShortcutInfoCompat> list) {
+        int i = -1;
+        String str = null;
+        for (ShortcutInfoCompat shortcutInfoCompat : list) {
+            if (shortcutInfoCompat.getRank() > i) {
+                str = shortcutInfoCompat.getId();
+                i = shortcutInfoCompat.getRank();
+            }
+        }
+        return str;
+    }
+
+    private static int getIconDimensionInternal(Context context, boolean z) {
+        ActivityManager activityManager = (ActivityManager) context.getSystemService("activity");
+        int max = Math.max(1, activityManager == null || activityManager.isLowRamDevice() ? 48 : 96);
+        DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
+        return (int) (max * ((z ? displayMetrics.xdpi : displayMetrics.ydpi) / 160.0f));
+    }
+
+    private static ShortcutInfoCompatSaver<?> getShortcutInfoSaverInstance(Context context) {
+        if (sShortcutInfoCompatSaver == null) {
+            if (Build.VERSION.SDK_INT >= 23) {
+                try {
+                    sShortcutInfoCompatSaver = (ShortcutInfoCompatSaver) Class.forName("androidx.sharetarget.ShortcutInfoCompatSaverImpl", false, ShortcutManagerCompat.class.getClassLoader()).getMethod("getInstance", Context.class).invoke(null, context);
+                } catch (Exception unused) {
+                }
+            }
+            if (sShortcutInfoCompatSaver == null) {
+                sShortcutInfoCompatSaver = new ShortcutInfoCompatSaver.NoopImpl();
+            }
+        }
+        return sShortcutInfoCompatSaver;
+    }
+
+    private static List<ShortcutInfoChangeListener> getShortcutInfoListeners(Context context) {
+        Bundle bundle;
+        String string;
+        if (sShortcutInfoChangeListeners == null) {
+            ArrayList arrayList = new ArrayList();
+            PackageManager packageManager = context.getPackageManager();
+            Intent intent = new Intent(SHORTCUT_LISTENER_INTENT_FILTER_ACTION);
+            intent.setPackage(context.getPackageName());
+            Iterator<ResolveInfo> it = packageManager.queryIntentActivities(intent, 128).iterator();
+            while (it.hasNext()) {
+                ActivityInfo activityInfo = it.next().activityInfo;
+                if (activityInfo != null && (bundle = activityInfo.metaData) != null && (string = bundle.getString(SHORTCUT_LISTENER_META_DATA_KEY)) != null) {
+                    try {
+                        arrayList.add((ShortcutInfoChangeListener) Class.forName(string, false, ShortcutManagerCompat.class.getClassLoader()).getMethod("getInstance", Context.class).invoke(null, context));
+                    } catch (Exception unused) {
+                    }
+                }
+            }
+            if (sShortcutInfoChangeListeners == null) {
+                sShortcutInfoChangeListeners = arrayList;
+            }
+        }
+        return sShortcutInfoChangeListeners;
+    }
+
+    private static List<ShortcutInfoCompat> removeShortcutsExcludedFromSurface(List<ShortcutInfoCompat> list, int i) {
+        Objects.requireNonNull(list);
+        if (Build.VERSION.SDK_INT > 31) {
+            return list;
+        }
+        ArrayList arrayList = new ArrayList(list);
+        for (ShortcutInfoCompat shortcutInfoCompat : list) {
+            if (shortcutInfoCompat.isExcludedFromSurfaces(i)) {
+                arrayList.remove(shortcutInfoCompat);
+            }
+        }
+        return arrayList;
+    }
+
+    private static class Api25Impl {
+        private Api25Impl() {
+        }
+
+        static String getShortcutInfoWithLowestRank(List<ShortcutInfo> list) {
+            int i = -1;
+            String str = null;
+            for (ShortcutInfo shortcutInfo : list) {
+                if (shortcutInfo.getRank() > i) {
+                    str = shortcutInfo.getId();
+                    i = shortcutInfo.getRank();
+                }
+            }
+            return str;
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/pm/ShortcutXmlParser.java

@@ -0,0 +1,102 @@
+package androidx.core.content.pm;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ResolveInfo;
+import android.content.res.XmlResourceParser;
+import android.os.Bundle;
+import android.util.Log;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+/* loaded from: classes.dex */
+public class ShortcutXmlParser {
+    private static final String ATTR_SHORTCUT_ID = "shortcutId";
+    private static final Object GET_INSTANCE_LOCK = new Object();
+    private static final String META_DATA_APP_SHORTCUTS = "android.app.shortcuts";
+    private static final String TAG = "ShortcutXmlParser";
+    private static final String TAG_SHORTCUT = "shortcut";
+    private static volatile ArrayList<String> sShortcutIds;
+
+    public static List<String> getShortcutIds(Context context) {
+        if (sShortcutIds == null) {
+            synchronized (GET_INSTANCE_LOCK) {
+                if (sShortcutIds == null) {
+                    sShortcutIds = new ArrayList<>();
+                    sShortcutIds.addAll(parseShortcutIds(context));
+                }
+            }
+        }
+        return sShortcutIds;
+    }
+
+    private ShortcutXmlParser() {
+    }
+
+    private static Set<String> parseShortcutIds(Context context) {
+        HashSet hashSet = new HashSet();
+        Intent intent = new Intent("android.intent.action.MAIN");
+        intent.addCategory("android.intent.category.LAUNCHER");
+        intent.setPackage(context.getPackageName());
+        List<ResolveInfo> queryIntentActivities = context.getPackageManager().queryIntentActivities(intent, 128);
+        if (queryIntentActivities != null && queryIntentActivities.size() != 0) {
+            try {
+                Iterator<ResolveInfo> it = queryIntentActivities.iterator();
+                while (it.hasNext()) {
+                    ActivityInfo activityInfo = it.next().activityInfo;
+                    Bundle bundle = activityInfo.metaData;
+                    if (bundle != null && bundle.containsKey(META_DATA_APP_SHORTCUTS)) {
+                        XmlResourceParser xmlResourceParser = getXmlResourceParser(context, activityInfo);
+                        try {
+                            hashSet.addAll(parseShortcutIds(xmlResourceParser));
+                            if (xmlResourceParser != null) {
+                                xmlResourceParser.close();
+                            }
+                        } finally {
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Failed to parse the Xml resource: ", e);
+            }
+        }
+        return hashSet;
+    }
+
+    private static XmlResourceParser getXmlResourceParser(Context context, ActivityInfo activityInfo) {
+        XmlResourceParser loadXmlMetaData = activityInfo.loadXmlMetaData(context.getPackageManager(), META_DATA_APP_SHORTCUTS);
+        if (loadXmlMetaData != null) {
+            return loadXmlMetaData;
+        }
+        throw new IllegalArgumentException("Failed to open android.app.shortcuts meta-data resource of " + activityInfo.name);
+    }
+
+    public static List<String> parseShortcutIds(XmlPullParser xmlPullParser) throws IOException, XmlPullParserException {
+        String attributeValue;
+        ArrayList arrayList = new ArrayList(1);
+        while (true) {
+            int next = xmlPullParser.next();
+            if (next == 1 || (next == 3 && xmlPullParser.getDepth() <= 0)) {
+                break;
+            }
+            int depth = xmlPullParser.getDepth();
+            String name = xmlPullParser.getName();
+            if (next == 2 && depth == 2 && TAG_SHORTCUT.equals(name) && (attributeValue = getAttributeValue(xmlPullParser, ATTR_SHORTCUT_ID)) != null) {
+                arrayList.add(attributeValue);
+            }
+        }
+        return arrayList;
+    }
+
+    private static String getAttributeValue(XmlPullParser xmlPullParser, String str) {
+        String attributeValue = xmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", str);
+        return attributeValue == null ? xmlPullParser.getAttributeValue(null, str) : attributeValue;
+    }
+}

02-Easy5/E5/sources/androidx/core/content/res/CamColor.java

@@ -0,0 +1,244 @@
+package androidx.core.content.res;
+
+import androidx.core.graphics.ColorUtils;
+
+/* loaded from: classes.dex */
+class CamColor {
+    private static final float CHROMA_SEARCH_ENDPOINT = 0.4f;
+    private static final float DE_MAX = 1.0f;
+    private static final float DL_MAX = 0.2f;
+    private static final float LIGHTNESS_SEARCH_ENDPOINT = 0.01f;
+    private final float mAstar;
+    private final float mBstar;
+    private final float mChroma;
+    private final float mHue;
+    private final float mJ;
+    private final float mJstar;
+    private final float mM;
+    private final float mQ;
+    private final float mS;
+
+    float getAStar() {
+        return this.mAstar;
+    }
+
+    float getBStar() {
+        return this.mBstar;
+    }
+
+    float getChroma() {
+        return this.mChroma;
+    }
+
+    float getHue() {
+        return this.mHue;
+    }
+
+    float getJ() {
+        return this.mJ;
+    }
+
+    float getJStar() {
+        return this.mJstar;
+    }
+
+    float getM() {
+        return this.mM;
+    }
+
+    float getQ() {
+        return this.mQ;
+    }
+
+    float getS() {
+        return this.mS;
+    }
+
+    CamColor(float f, float f2, float f3, float f4, float f5, float f6, float f7, float f8, float f9) {
+        this.mHue = f;
+        this.mChroma = f2;
+        this.mJ = f3;
+        this.mQ = f4;
+        this.mM = f5;
+        this.mS = f6;
+        this.mJstar = f7;
+        this.mAstar = f8;
+        this.mBstar = f9;
+    }
+
+    static int toColor(float f, float f2, float f3) {
+        return toColor(f, f2, f3, ViewingConditions.DEFAULT);
+    }
+
+    static CamColor fromColor(int i) {
+        return fromColorInViewingConditions(i, ViewingConditions.DEFAULT);
+    }
+
+    static CamColor fromColorInViewingConditions(int i, ViewingConditions viewingConditions) {
+        float[] xyzFromInt = CamUtils.xyzFromInt(i);
+        float[][] fArr = CamUtils.XYZ_TO_CAM16RGB;
+        float f = xyzFromInt[0];
+        float[] fArr2 = fArr[0];
+        float f2 = fArr2[0] * f;
+        float f3 = xyzFromInt[1];
+        float f4 = f2 + (fArr2[1] * f3);
+        float f5 = xyzFromInt[2];
+        float f6 = f4 + (fArr2[2] * f5);
+        float[] fArr3 = fArr[1];
+        float f7 = (fArr3[0] * f) + (fArr3[1] * f3) + (fArr3[2] * f5);
+        float[] fArr4 = fArr[2];
+        float f8 = (f * fArr4[0]) + (f3 * fArr4[1]) + (f5 * fArr4[2]);
+        float f9 = viewingConditions.getRgbD()[0] * f6;
+        float f10 = viewingConditions.getRgbD()[1] * f7;
+        float f11 = viewingConditions.getRgbD()[2] * f8;
+        float pow = (float) Math.pow((viewingConditions.getFl() * Math.abs(f9)) / 100.0d, 0.42d);
+        float pow2 = (float) Math.pow((viewingConditions.getFl() * Math.abs(f10)) / 100.0d, 0.42d);
+        float pow3 = (float) Math.pow((viewingConditions.getFl() * Math.abs(f11)) / 100.0d, 0.42d);
+        float signum = ((Math.signum(f9) * 400.0f) * pow) / (pow + 27.13f);
+        float signum2 = ((Math.signum(f10) * 400.0f) * pow2) / (pow2 + 27.13f);
+        float signum3 = ((Math.signum(f11) * 400.0f) * pow3) / (pow3 + 27.13f);
+        double d = signum3;
+        float f12 = ((float) (((signum * 11.0d) + (signum2 * (-12.0d))) + d)) / 11.0f;
+        float f13 = ((float) ((signum + signum2) - (d * 2.0d))) / 9.0f;
+        float f14 = signum2 * 20.0f;
+        float f15 = (((signum * 20.0f) + f14) + (21.0f * signum3)) / 20.0f;
+        float f16 = (((signum * 40.0f) + f14) + signum3) / 20.0f;
+        float atan2 = (((float) Math.atan2(f13, f12)) * 180.0f) / 3.1415927f;
+        if (atan2 < 0.0f) {
+            atan2 += 360.0f;
+        } else if (atan2 >= 360.0f) {
+            atan2 -= 360.0f;
+        }
+        float f17 = atan2;
+        float f18 = (3.1415927f * f17) / 180.0f;
+        float pow4 = ((float) Math.pow((f16 * viewingConditions.getNbb()) / viewingConditions.getAw(), viewingConditions.getC() * viewingConditions.getZ())) * 100.0f;
+        float flRoot = viewingConditions.getFlRoot() * (4.0f / viewingConditions.getC()) * ((float) Math.sqrt(pow4 / 100.0f)) * (viewingConditions.getAw() + 4.0f);
+        float pow5 = ((float) Math.pow(1.64d - Math.pow(0.29d, viewingConditions.getN()), 0.73d)) * ((float) Math.pow((((((((float) (Math.cos((((((double) f17) < 20.14d ? 360.0f + f17 : f17) * 3.141592653589793d) / 180.0d) + 2.0d) + 3.8d)) * 0.25f) * 3846.1538f) * viewingConditions.getNc()) * viewingConditions.getNcb()) * ((float) Math.sqrt((f12 * f12) + (f13 * f13)))) / (f15 + 0.305f), 0.9d)) * ((float) Math.sqrt(pow4 / 100.0d));
+        float flRoot2 = pow5 * viewingConditions.getFlRoot();
+        float sqrt = ((float) Math.sqrt((r3 * viewingConditions.getC()) / (viewingConditions.getAw() + 4.0f))) * 50.0f;
+        float f19 = (1.7f * pow4) / ((0.007f * pow4) + 1.0f);
+        float log = ((float) Math.log((0.0228f * flRoot2) + 1.0f)) * 43.85965f;
+        double d2 = f18;
+        return new CamColor(f17, pow5, pow4, flRoot, flRoot2, sqrt, f19, log * ((float) Math.cos(d2)), log * ((float) Math.sin(d2)));
+    }
+
+    private static CamColor fromJch(float f, float f2, float f3) {
+        return fromJchInFrame(f, f2, f3, ViewingConditions.DEFAULT);
+    }
+
+    private static CamColor fromJchInFrame(float f, float f2, float f3, ViewingConditions viewingConditions) {
+        float c = (4.0f / viewingConditions.getC()) * ((float) Math.sqrt(f / 100.0d)) * (viewingConditions.getAw() + 4.0f) * viewingConditions.getFlRoot();
+        float flRoot = f2 * viewingConditions.getFlRoot();
+        float sqrt = ((float) Math.sqrt(((f2 / ((float) Math.sqrt(r4))) * viewingConditions.getC()) / (viewingConditions.getAw() + 4.0f))) * 50.0f;
+        float f4 = (1.7f * f) / ((0.007f * f) + 1.0f);
+        float log = ((float) Math.log((flRoot * 0.0228d) + 1.0d)) * 43.85965f;
+        double d = (3.1415927f * f3) / 180.0f;
+        return new CamColor(f3, f2, f, c, flRoot, sqrt, f4, log * ((float) Math.cos(d)), log * ((float) Math.sin(d)));
+    }
+
+    float distance(CamColor camColor) {
+        float jStar = getJStar() - camColor.getJStar();
+        float aStar = getAStar() - camColor.getAStar();
+        float bStar = getBStar() - camColor.getBStar();
+        return (float) (Math.pow(Math.sqrt((jStar * jStar) + (aStar * aStar) + (bStar * bStar)), 0.63d) * 1.41d);
+    }
+
+    int viewedInSrgb() {
+        return viewed(ViewingConditions.DEFAULT);
+    }
+
+    int viewed(ViewingConditions viewingConditions) {
+        float pow = (float) Math.pow(((((double) getChroma()) == 0.0d || ((double) getJ()) == 0.0d) ? 0.0f : getChroma() / ((float) Math.sqrt(getJ() / 100.0d))) / Math.pow(1.64d - Math.pow(0.29d, viewingConditions.getN()), 0.73d), 1.1111111111111112d);
+        double hue = (getHue() * 3.1415927f) / 180.0f;
+        float cos = ((float) (Math.cos(2.0d + hue) + 3.8d)) * 0.25f;
+        float aw = viewingConditions.getAw() * ((float) Math.pow(getJ() / 100.0d, (1.0d / viewingConditions.getC()) / viewingConditions.getZ()));
+        float nc = cos * 3846.1538f * viewingConditions.getNc() * viewingConditions.getNcb();
+        float nbb = aw / viewingConditions.getNbb();
+        float sin = (float) Math.sin(hue);
+        float cos2 = (float) Math.cos(hue);
+        float f = (((0.305f + nbb) * 23.0f) * pow) / (((nc * 23.0f) + ((11.0f * pow) * cos2)) + ((pow * 108.0f) * sin));
+        float f2 = cos2 * f;
+        float f3 = f * sin;
+        float f4 = nbb * 460.0f;
+        float f5 = (((451.0f * f2) + f4) + (288.0f * f3)) / 1403.0f;
+        float f6 = ((f4 - (891.0f * f2)) - (261.0f * f3)) / 1403.0f;
+        float signum = Math.signum(f5) * (100.0f / viewingConditions.getFl()) * ((float) Math.pow((float) Math.max(0.0d, (Math.abs(f5) * 27.13d) / (400.0d - Math.abs(f5))), 2.380952380952381d));
+        float signum2 = Math.signum(f6) * (100.0f / viewingConditions.getFl()) * ((float) Math.pow((float) Math.max(0.0d, (Math.abs(f6) * 27.13d) / (400.0d - Math.abs(f6))), 2.380952380952381d));
+        float signum3 = Math.signum(((f4 - (f2 * 220.0f)) - (f3 * 6300.0f)) / 1403.0f) * (100.0f / viewingConditions.getFl()) * ((float) Math.pow((float) Math.max(0.0d, (Math.abs(r8) * 27.13d) / (400.0d - Math.abs(r8))), 2.380952380952381d));
+        float f7 = signum / viewingConditions.getRgbD()[0];
+        float f8 = signum2 / viewingConditions.getRgbD()[1];
+        float f9 = signum3 / viewingConditions.getRgbD()[2];
+        float[][] fArr = CamUtils.CAM16RGB_TO_XYZ;
+        float[] fArr2 = fArr[0];
+        float f10 = (fArr2[0] * f7) + (fArr2[1] * f8) + (fArr2[2] * f9);
+        float[] fArr3 = fArr[1];
+        float f11 = (fArr3[0] * f7) + (fArr3[1] * f8) + (fArr3[2] * f9);
+        float[] fArr4 = fArr[2];
+        return ColorUtils.XYZToColor(f10, f11, (f7 * fArr4[0]) + (f8 * fArr4[1]) + (f9 * fArr4[2]));
+    }
+
+    static int toColor(float f, float f2, float f3, ViewingConditions viewingConditions) {
+        if (f2 < 1.0d || Math.round(f3) <= 0.0d || Math.round(f3) >= 100.0d) {
+            return CamUtils.intFromLStar(f3);
+        }
+        float min = f < 0.0f ? 0.0f : Math.min(360.0f, f);
+        float f4 = f2;
+        CamColor camColor = null;
+        float f5 = 0.0f;
+        boolean z = true;
+        while (Math.abs(f5 - f2) >= CHROMA_SEARCH_ENDPOINT) {
+            CamColor findCamByJ = findCamByJ(min, f4, f3);
+            if (!z) {
+                if (findCamByJ == null) {
+                    f2 = f4;
+                } else {
+                    f5 = f4;
+                    camColor = findCamByJ;
+                }
+                f4 = ((f2 - f5) / 2.0f) + f5;
+            } else {
+                if (findCamByJ != null) {
+                    return findCamByJ.viewed(viewingConditions);
+                }
+                f4 = ((f2 - f5) / 2.0f) + f5;
+                z = false;
+            }
+        }
+        if (camColor == null) {
+            return CamUtils.intFromLStar(f3);
+        }
+        return camColor.viewed(viewingConditions);
+    }
+
+    private static CamColor findCamByJ(float f, float f2, float f3) {
+        float f4 = 100.0f;
+        float f5 = 1000.0f;
+        CamColor camColor = null;
+        float f6 = 1000.0f;
+        float f7 = 0.0f;
+        while (Math.abs(f7 - f4) > LIGHTNESS_SEARCH_ENDPOINT) {
+            float f8 = ((f4 - f7) / 2.0f) + f7;
+            int viewedInSrgb = fromJch(f8, f2, f).viewedInSrgb();
+            float lStarFromInt = CamUtils.lStarFromInt(viewedInSrgb);
+            float abs = Math.abs(f3 - lStarFromInt);
+            if (abs < 0.2f) {
+                CamColor fromColor = fromColor(viewedInSrgb);
+                float distance = fromColor.distance(fromJch(fromColor.getJ(), fromColor.getChroma(), f));
+                if (distance <= 1.0f) {
+                    camColor = fromColor;
+                    f5 = abs;
+                    f6 = distance;
+                }
+            }
+            if (f5 == 0.0f && f6 == 0.0f) {
+                break;
+            }
+            if (lStarFromInt < f3) {
+                f7 = f8;
+            } else {
+                f4 = f8;
+            }
+        }
+        return camColor;
+    }
+}

02-Easy5/E5/sources/androidx/core/content/res/CamUtils.java

@@ -0,0 +1,78 @@
+package androidx.core.content.res;
+
+import android.graphics.Color;
+import androidx.core.graphics.ColorUtils;
+import androidx.core.view.ViewCompat;
+
+/* loaded from: classes.dex */
+final class CamUtils {
+    static final float[][] XYZ_TO_CAM16RGB = {new float[]{0.401288f, 0.650173f, -0.051461f}, new float[]{-0.250268f, 1.204414f, 0.045854f}, new float[]{-0.002079f, 0.048952f, 0.953127f}};
+    static final float[][] CAM16RGB_TO_XYZ = {new float[]{1.8620678f, -1.0112547f, 0.14918678f}, new float[]{0.38752654f, 0.62144744f, -0.00897398f}, new float[]{-0.0158415f, -0.03412294f, 1.0499644f}};
+    static final float[] WHITE_POINT_D65 = {95.047f, 100.0f, 108.883f};
+    static final float[][] SRGB_TO_XYZ = {new float[]{0.41233894f, 0.35762063f, 0.18051042f}, new float[]{0.2126f, 0.7152f, 0.0722f}, new float[]{0.01932141f, 0.11916382f, 0.9503448f}};
+
+    static float lerp(float f, float f2, float f3) {
+        return f + ((f2 - f) * f3);
+    }
+
+    private CamUtils() {
+    }
+
+    static int intFromLStar(float f) {
+        if (f < 1.0f) {
+            return ViewCompat.MEASURED_STATE_MASK;
+        }
+        if (f > 99.0f) {
+            return -1;
+        }
+        float f2 = (f + 16.0f) / 116.0f;
+        float f3 = f > 8.0f ? f2 * f2 * f2 : f / 903.2963f;
+        float f4 = f2 * f2 * f2;
+        boolean z = f4 > 0.008856452f;
+        float f5 = z ? f4 : ((f2 * 116.0f) - 16.0f) / 903.2963f;
+        if (!z) {
+            f4 = ((f2 * 116.0f) - 16.0f) / 903.2963f;
+        }
+        float[] fArr = WHITE_POINT_D65;
+        return ColorUtils.XYZToColor(f5 * fArr[0], f3 * fArr[1], f4 * fArr[2]);
+    }
+
+    static float lStarFromInt(int i) {
+        return lStarFromY(yFromInt(i));
+    }
+
+    static float lStarFromY(float f) {
+        float f2 = f / 100.0f;
+        return f2 <= 0.008856452f ? f2 * 903.2963f : (((float) Math.cbrt(f2)) * 116.0f) - 16.0f;
+    }
+
+    static float yFromInt(int i) {
+        float linearized = linearized(Color.red(i));
+        float linearized2 = linearized(Color.green(i));
+        float linearized3 = linearized(Color.blue(i));
+        float[] fArr = SRGB_TO_XYZ[1];
+        return (linearized * fArr[0]) + (linearized2 * fArr[1]) + (linearized3 * fArr[2]);
+    }
+
+    static float[] xyzFromInt(int i) {
+        float linearized = linearized(Color.red(i));
+        float linearized2 = linearized(Color.green(i));
+        float linearized3 = linearized(Color.blue(i));
+        float[][] fArr = SRGB_TO_XYZ;
+        float[] fArr2 = fArr[0];
+        float f = (fArr2[0] * linearized) + (fArr2[1] * linearized2) + (fArr2[2] * linearized3);
+        float[] fArr3 = fArr[1];
+        float f2 = (fArr3[0] * linearized) + (fArr3[1] * linearized2) + (fArr3[2] * linearized3);
+        float[] fArr4 = fArr[2];
+        return new float[]{f, f2, (linearized * fArr4[0]) + (linearized2 * fArr4[1]) + (linearized3 * fArr4[2])};
+    }
+
+    static float yFromLStar(float f) {
+        return (f > 8.0f ? (float) Math.pow((f + 16.0d) / 116.0d, 3.0d) : f / 903.2963f) * 100.0f;
+    }
+
+    static float linearized(int i) {
+        float f = i / 255.0f;
+        return (f <= 0.04045f ? f / 12.92f : (float) Math.pow((f + 0.055f) / 1.055f, 2.4000000953674316d)) * 100.0f;
+    }
+}

02-Easy5/E5/sources/androidx/core/content/res/ColorStateListInflaterCompat.java

@@ -0,0 +1,163 @@
+package androidx.core.content.res;
+
+import android.content.res.ColorStateList;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.graphics.Color;
+import android.os.Build;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.util.StateSet;
+import android.util.TypedValue;
+import android.util.Xml;
+import androidx.core.R;
+import androidx.core.math.MathUtils;
+import androidx.core.view.ViewCompat;
+import java.io.IOException;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+/* loaded from: classes.dex */
+public final class ColorStateListInflaterCompat {
+    private static final ThreadLocal<TypedValue> sTempTypedValue = new ThreadLocal<>();
+
+    private ColorStateListInflaterCompat() {
+    }
+
+    public static ColorStateList inflate(Resources resources, int i, Resources.Theme theme) {
+        try {
+            return createFromXml(resources, resources.getXml(i), theme);
+        } catch (Exception e) {
+            Log.e("CSLCompat", "Failed to inflate ColorStateList.", e);
+            return null;
+        }
+    }
+
+    public static ColorStateList createFromXml(Resources resources, XmlPullParser xmlPullParser, Resources.Theme theme) throws XmlPullParserException, IOException {
+        int next;
+        AttributeSet asAttributeSet = Xml.asAttributeSet(xmlPullParser);
+        do {
+            next = xmlPullParser.next();
+            if (next == 2) {
+                break;
+            }
+        } while (next != 1);
+        if (next != 2) {
+            throw new XmlPullParserException("No start tag found");
+        }
+        return createFromXmlInner(resources, xmlPullParser, asAttributeSet, theme);
+    }
+
+    public static ColorStateList createFromXmlInner(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) throws XmlPullParserException, IOException {
+        String name = xmlPullParser.getName();
+        if (!name.equals("selector")) {
+            throw new XmlPullParserException(xmlPullParser.getPositionDescription() + ": invalid color state list tag " + name);
+        }
+        return inflate(resources, xmlPullParser, attributeSet, theme);
+    }
+
+    private static ColorStateList inflate(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) throws XmlPullParserException, IOException {
+        int depth;
+        int color;
+        float f;
+        Resources resources2 = resources;
+        int i = 1;
+        int depth2 = xmlPullParser.getDepth() + 1;
+        int[][] iArr = new int[20][];
+        int[] iArr2 = new int[20];
+        int i2 = 0;
+        while (true) {
+            int next = xmlPullParser.next();
+            if (next == i || ((depth = xmlPullParser.getDepth()) < depth2 && next == 3)) {
+                break;
+            }
+            if (next == 2 && depth <= depth2 && xmlPullParser.getName().equals("item")) {
+                TypedArray obtainAttributes = obtainAttributes(resources2, theme, attributeSet, R.styleable.ColorStateListItem);
+                int resourceId = obtainAttributes.getResourceId(R.styleable.ColorStateListItem_android_color, -1);
+                if (resourceId != -1 && !isColorInt(resources2, resourceId)) {
+                    try {
+                        color = createFromXml(resources2, resources2.getXml(resourceId), theme).getDefaultColor();
+                    } catch (Exception unused) {
+                        color = obtainAttributes.getColor(R.styleable.ColorStateListItem_android_color, -65281);
+                    }
+                } else {
+                    color = obtainAttributes.getColor(R.styleable.ColorStateListItem_android_color, -65281);
+                }
+                float f2 = 1.0f;
+                if (obtainAttributes.hasValue(R.styleable.ColorStateListItem_android_alpha)) {
+                    f2 = obtainAttributes.getFloat(R.styleable.ColorStateListItem_android_alpha, 1.0f);
+                } else if (obtainAttributes.hasValue(R.styleable.ColorStateListItem_alpha)) {
+                    f2 = obtainAttributes.getFloat(R.styleable.ColorStateListItem_alpha, 1.0f);
+                }
+                if (Build.VERSION.SDK_INT >= 31 && obtainAttributes.hasValue(R.styleable.ColorStateListItem_android_lStar)) {
+                    f = obtainAttributes.getFloat(R.styleable.ColorStateListItem_android_lStar, -1.0f);
+                } else {
+                    f = obtainAttributes.getFloat(R.styleable.ColorStateListItem_lStar, -1.0f);
+                }
+                obtainAttributes.recycle();
+                int attributeCount = attributeSet.getAttributeCount();
+                int[] iArr3 = new int[attributeCount];
+                int i3 = 0;
+                for (int i4 = 0; i4 < attributeCount; i4++) {
+                    int attributeNameResource = attributeSet.getAttributeNameResource(i4);
+                    if (attributeNameResource != 16843173 && attributeNameResource != 16843551 && attributeNameResource != R.attr.alpha && attributeNameResource != R.attr.lStar) {
+                        int i5 = i3 + 1;
+                        if (!attributeSet.getAttributeBooleanValue(i4, false)) {
+                            attributeNameResource = -attributeNameResource;
+                        }
+                        iArr3[i3] = attributeNameResource;
+                        i3 = i5;
+                    }
+                }
+                int[] trimStateSet = StateSet.trimStateSet(iArr3, i3);
+                iArr2 = GrowingArrayUtils.append(iArr2, i2, modulateColorAlpha(color, f2, f));
+                iArr = (int[][]) GrowingArrayUtils.append(iArr, i2, trimStateSet);
+                i2++;
+            }
+            i = 1;
+            resources2 = resources;
+        }
+        int[] iArr4 = new int[i2];
+        int[][] iArr5 = new int[i2][];
+        System.arraycopy(iArr2, 0, iArr4, 0, i2);
+        System.arraycopy(iArr, 0, iArr5, 0, i2);
+        return new ColorStateList(iArr5, iArr4);
+    }
+
+    private static boolean isColorInt(Resources resources, int i) {
+        TypedValue typedValue = getTypedValue();
+        resources.getValue(i, typedValue, true);
+        return typedValue.type >= 28 && typedValue.type <= 31;
+    }
+
+    private static TypedValue getTypedValue() {
+        ThreadLocal<TypedValue> threadLocal = sTempTypedValue;
+        TypedValue typedValue = threadLocal.get();
+        if (typedValue != null) {
+            return typedValue;
+        }
+        TypedValue typedValue2 = new TypedValue();
+        threadLocal.set(typedValue2);
+        return typedValue2;
+    }
+
+    private static TypedArray obtainAttributes(Resources resources, Resources.Theme theme, AttributeSet attributeSet, int[] iArr) {
+        if (theme == null) {
+            return resources.obtainAttributes(attributeSet, iArr);
+        }
+        return theme.obtainStyledAttributes(attributeSet, iArr, 0, 0);
+    }
+
+    private static int modulateColorAlpha(int i, float f, float f2) {
+        boolean z = f2 >= 0.0f && f2 <= 100.0f;
+        if (f == 1.0f && !z) {
+            return i;
+        }
+        int clamp = MathUtils.clamp((int) ((Color.alpha(i) * f) + 0.5f), 0, 255);
+        if (z) {
+            CamColor fromColor = CamColor.fromColor(i);
+            i = CamColor.toColor(fromColor.getHue(), fromColor.getChroma(), f2);
+        }
+        return (i & ViewCompat.MEASURED_SIZE_MASK) | (clamp << 24);
+    }
+}

02-Easy5/E5/sources/androidx/core/content/res/ComplexColorCompat.java

@@ -0,0 +1,107 @@
+package androidx.core.content.res;
+
+import android.content.res.ColorStateList;
+import android.content.res.Resources;
+import android.content.res.XmlResourceParser;
+import android.graphics.Shader;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.util.Xml;
+import java.io.IOException;
+import org.xmlpull.v1.XmlPullParserException;
+
+/* loaded from: classes.dex */
+public final class ComplexColorCompat {
+    private static final String LOG_TAG = "ComplexColorCompat";
+    private int mColor;
+    private final ColorStateList mColorStateList;
+    private final Shader mShader;
+
+    public int getColor() {
+        return this.mColor;
+    }
+
+    public Shader getShader() {
+        return this.mShader;
+    }
+
+    public boolean isGradient() {
+        return this.mShader != null;
+    }
+
+    public void setColor(int i) {
+        this.mColor = i;
+    }
+
+    private ComplexColorCompat(Shader shader, ColorStateList colorStateList, int i) {
+        this.mShader = shader;
+        this.mColorStateList = colorStateList;
+        this.mColor = i;
+    }
+
+    static ComplexColorCompat from(Shader shader) {
+        return new ComplexColorCompat(shader, null, 0);
+    }
+
+    static ComplexColorCompat from(ColorStateList colorStateList) {
+        return new ComplexColorCompat(null, colorStateList, colorStateList.getDefaultColor());
+    }
+
+    static ComplexColorCompat from(int i) {
+        return new ComplexColorCompat(null, null, i);
+    }
+
+    public boolean isStateful() {
+        ColorStateList colorStateList;
+        return this.mShader == null && (colorStateList = this.mColorStateList) != null && colorStateList.isStateful();
+    }
+
+    public boolean onStateChanged(int[] iArr) {
+        if (isStateful()) {
+            ColorStateList colorStateList = this.mColorStateList;
+            int colorForState = colorStateList.getColorForState(iArr, colorStateList.getDefaultColor());
+            if (colorForState != this.mColor) {
+                this.mColor = colorForState;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean willDraw() {
+        return isGradient() || this.mColor != 0;
+    }
+
+    public static ComplexColorCompat inflate(Resources resources, int i, Resources.Theme theme) {
+        try {
+            return createFromXml(resources, i, theme);
+        } catch (Exception e) {
+            Log.e(LOG_TAG, "Failed to inflate ComplexColor.", e);
+            return null;
+        }
+    }
+
+    private static ComplexColorCompat createFromXml(Resources resources, int i, Resources.Theme theme) throws IOException, XmlPullParserException {
+        int next;
+        XmlResourceParser xml = resources.getXml(i);
+        AttributeSet asAttributeSet = Xml.asAttributeSet(xml);
+        do {
+            next = xml.next();
+            if (next == 2) {
+                break;
+            }
+        } while (next != 1);
+        if (next != 2) {
+            throw new XmlPullParserException("No start tag found");
+        }
+        String name = xml.getName();
+        name.hashCode();
+        if (name.equals("gradient")) {
+            return from(GradientColorInflaterCompat.createFromXmlInner(resources, xml, asAttributeSet, theme));
+        }
+        if (name.equals("selector")) {
+            return from(ColorStateListInflaterCompat.createFromXmlInner(resources, xml, asAttributeSet, theme));
+        }
+        throw new XmlPullParserException(xml.getPositionDescription() + ": unsupported complex color tag " + name);
+    }
+}

02-Easy5/E5/sources/androidx/core/content/res/ConfigurationHelper.java

@@ -0,0 +1,13 @@
+package androidx.core.content.res;
+
+import android.content.res.Resources;
+
+/* loaded from: classes.dex */
+public final class ConfigurationHelper {
+    private ConfigurationHelper() {
+    }
+
+    public static int getDensityDpi(Resources resources) {
+        return resources.getConfiguration().densityDpi;
+    }
+}

02-Easy5/E5/sources/androidx/core/content/res/FontResourcesParserCompat.java

@@ -0,0 +1,283 @@
+package androidx.core.content.res;
+
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.util.Base64;
+import android.util.Xml;
+import androidx.core.R;
+import androidx.core.provider.FontRequest;
+import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+/* loaded from: classes.dex */
+public class FontResourcesParserCompat {
+    private static final int DEFAULT_TIMEOUT_MILLIS = 500;
+    public static final int FETCH_STRATEGY_ASYNC = 1;
+    public static final int FETCH_STRATEGY_BLOCKING = 0;
+    public static final int INFINITE_TIMEOUT_VALUE = -1;
+    private static final int ITALIC = 1;
+    private static final int NORMAL_WEIGHT = 400;
+
+    public interface FamilyResourceEntry {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface FetchStrategy {
+    }
+
+    public static final class ProviderResourceEntry implements FamilyResourceEntry {
+        private final FontRequest mRequest;
+        private final int mStrategy;
+        private final String mSystemFontFamilyName;
+        private final int mTimeoutMs;
+
+        public int getFetchStrategy() {
+            return this.mStrategy;
+        }
+
+        public FontRequest getRequest() {
+            return this.mRequest;
+        }
+
+        public String getSystemFontFamilyName() {
+            return this.mSystemFontFamilyName;
+        }
+
+        public int getTimeout() {
+            return this.mTimeoutMs;
+        }
+
+        public ProviderResourceEntry(FontRequest fontRequest, int i, int i2, String str) {
+            this.mRequest = fontRequest;
+            this.mStrategy = i;
+            this.mTimeoutMs = i2;
+            this.mSystemFontFamilyName = str;
+        }
+
+        public ProviderResourceEntry(FontRequest fontRequest, int i, int i2) {
+            this(fontRequest, i, i2, null);
+        }
+    }
+
+    public static final class FontFileResourceEntry {
+        private final String mFileName;
+        private final boolean mItalic;
+        private final int mResourceId;
+        private final int mTtcIndex;
+        private final String mVariationSettings;
+        private final int mWeight;
+
+        public String getFileName() {
+            return this.mFileName;
+        }
+
+        public int getResourceId() {
+            return this.mResourceId;
+        }
+
+        public int getTtcIndex() {
+            return this.mTtcIndex;
+        }
+
+        public String getVariationSettings() {
+            return this.mVariationSettings;
+        }
+
+        public int getWeight() {
+            return this.mWeight;
+        }
+
+        public boolean isItalic() {
+            return this.mItalic;
+        }
+
+        public FontFileResourceEntry(String str, int i, boolean z, String str2, int i2, int i3) {
+            this.mFileName = str;
+            this.mWeight = i;
+            this.mItalic = z;
+            this.mVariationSettings = str2;
+            this.mTtcIndex = i2;
+            this.mResourceId = i3;
+        }
+    }
+
+    public static final class FontFamilyFilesResourceEntry implements FamilyResourceEntry {
+        private final FontFileResourceEntry[] mEntries;
+
+        public FontFileResourceEntry[] getEntries() {
+            return this.mEntries;
+        }
+
+        public FontFamilyFilesResourceEntry(FontFileResourceEntry[] fontFileResourceEntryArr) {
+            this.mEntries = fontFileResourceEntryArr;
+        }
+    }
+
+    public static FamilyResourceEntry parse(XmlPullParser xmlPullParser, Resources resources) throws XmlPullParserException, IOException {
+        int next;
+        do {
+            next = xmlPullParser.next();
+            if (next == 2) {
+                break;
+            }
+        } while (next != 1);
+        if (next != 2) {
+            throw new XmlPullParserException("No start tag found");
+        }
+        return readFamilies(xmlPullParser, resources);
+    }
+
+    private static FamilyResourceEntry readFamilies(XmlPullParser xmlPullParser, Resources resources) throws XmlPullParserException, IOException {
+        xmlPullParser.require(2, null, "font-family");
+        if (xmlPullParser.getName().equals("font-family")) {
+            return readFamily(xmlPullParser, resources);
+        }
+        skip(xmlPullParser);
+        return null;
+    }
+
+    private static FamilyResourceEntry readFamily(XmlPullParser xmlPullParser, Resources resources) throws XmlPullParserException, IOException {
+        TypedArray obtainAttributes = resources.obtainAttributes(Xml.asAttributeSet(xmlPullParser), R.styleable.FontFamily);
+        String string = obtainAttributes.getString(R.styleable.FontFamily_fontProviderAuthority);
+        String string2 = obtainAttributes.getString(R.styleable.FontFamily_fontProviderPackage);
+        String string3 = obtainAttributes.getString(R.styleable.FontFamily_fontProviderQuery);
+        int resourceId = obtainAttributes.getResourceId(R.styleable.FontFamily_fontProviderCerts, 0);
+        int integer = obtainAttributes.getInteger(R.styleable.FontFamily_fontProviderFetchStrategy, 1);
+        int integer2 = obtainAttributes.getInteger(R.styleable.FontFamily_fontProviderFetchTimeout, DEFAULT_TIMEOUT_MILLIS);
+        String string4 = obtainAttributes.getString(R.styleable.FontFamily_fontProviderSystemFontFamily);
+        obtainAttributes.recycle();
+        if (string != null && string2 != null && string3 != null) {
+            while (xmlPullParser.next() != 3) {
+                skip(xmlPullParser);
+            }
+            return new ProviderResourceEntry(new FontRequest(string, string2, string3, readCerts(resources, resourceId)), integer, integer2, string4);
+        }
+        ArrayList arrayList = new ArrayList();
+        while (xmlPullParser.next() != 3) {
+            if (xmlPullParser.getEventType() == 2) {
+                if (xmlPullParser.getName().equals("font")) {
+                    arrayList.add(readFont(xmlPullParser, resources));
+                } else {
+                    skip(xmlPullParser);
+                }
+            }
+        }
+        if (arrayList.isEmpty()) {
+            return null;
+        }
+        return new FontFamilyFilesResourceEntry((FontFileResourceEntry[]) arrayList.toArray(new FontFileResourceEntry[0]));
+    }
+
+    private static int getType(TypedArray typedArray, int i) {
+        return Api21Impl.getType(typedArray, i);
+    }
+
+    public static List<List<byte[]>> readCerts(Resources resources, int i) {
+        if (i == 0) {
+            return Collections.emptyList();
+        }
+        TypedArray obtainTypedArray = resources.obtainTypedArray(i);
+        try {
+            if (obtainTypedArray.length() == 0) {
+                return Collections.emptyList();
+            }
+            ArrayList arrayList = new ArrayList();
+            if (getType(obtainTypedArray, 0) == 1) {
+                for (int i2 = 0; i2 < obtainTypedArray.length(); i2++) {
+                    int resourceId = obtainTypedArray.getResourceId(i2, 0);
+                    if (resourceId != 0) {
+                        arrayList.add(toByteArrayList(resources.getStringArray(resourceId)));
+                    }
+                }
+            } else {
+                arrayList.add(toByteArrayList(resources.getStringArray(i)));
+            }
+            return arrayList;
+        } finally {
+            obtainTypedArray.recycle();
+        }
+    }
+
+    private static List<byte[]> toByteArrayList(String[] strArr) {
+        ArrayList arrayList = new ArrayList();
+        for (String str : strArr) {
+            arrayList.add(Base64.decode(str, 0));
+        }
+        return arrayList;
+    }
+
+    private static FontFileResourceEntry readFont(XmlPullParser xmlPullParser, Resources resources) throws XmlPullParserException, IOException {
+        int i;
+        int i2;
+        int i3;
+        int i4;
+        int i5;
+        TypedArray obtainAttributes = resources.obtainAttributes(Xml.asAttributeSet(xmlPullParser), R.styleable.FontFamilyFont);
+        if (obtainAttributes.hasValue(R.styleable.FontFamilyFont_fontWeight)) {
+            i = R.styleable.FontFamilyFont_fontWeight;
+        } else {
+            i = R.styleable.FontFamilyFont_android_fontWeight;
+        }
+        int i6 = obtainAttributes.getInt(i, NORMAL_WEIGHT);
+        if (obtainAttributes.hasValue(R.styleable.FontFamilyFont_fontStyle)) {
+            i2 = R.styleable.FontFamilyFont_fontStyle;
+        } else {
+            i2 = R.styleable.FontFamilyFont_android_fontStyle;
+        }
+        boolean z = 1 == obtainAttributes.getInt(i2, 0);
+        if (obtainAttributes.hasValue(R.styleable.FontFamilyFont_ttcIndex)) {
+            i3 = R.styleable.FontFamilyFont_ttcIndex;
+        } else {
+            i3 = R.styleable.FontFamilyFont_android_ttcIndex;
+        }
+        if (obtainAttributes.hasValue(R.styleable.FontFamilyFont_fontVariationSettings)) {
+            i4 = R.styleable.FontFamilyFont_fontVariationSettings;
+        } else {
+            i4 = R.styleable.FontFamilyFont_android_fontVariationSettings;
+        }
+        String string = obtainAttributes.getString(i4);
+        int i7 = obtainAttributes.getInt(i3, 0);
+        if (obtainAttributes.hasValue(R.styleable.FontFamilyFont_font)) {
+            i5 = R.styleable.FontFamilyFont_font;
+        } else {
+            i5 = R.styleable.FontFamilyFont_android_font;
+        }
+        int resourceId = obtainAttributes.getResourceId(i5, 0);
+        String string2 = obtainAttributes.getString(i5);
+        obtainAttributes.recycle();
+        while (xmlPullParser.next() != 3) {
+            skip(xmlPullParser);
+        }
+        return new FontFileResourceEntry(string2, i6, z, string, i7, resourceId);
+    }
+
+    private static void skip(XmlPullParser xmlPullParser) throws XmlPullParserException, IOException {
+        int i = 1;
+        while (i > 0) {
+            int next = xmlPullParser.next();
+            if (next == 2) {
+                i++;
+            } else if (next == 3) {
+                i--;
+            }
+        }
+    }
+
+    private FontResourcesParserCompat() {
+    }
+
+    static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        static int getType(TypedArray typedArray, int i) {
+            return typedArray.getType(i);
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/res/GradientColorInflaterCompat.java

@@ -0,0 +1,199 @@
+package androidx.core.content.res;
+
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.graphics.LinearGradient;
+import android.graphics.RadialGradient;
+import android.graphics.Shader;
+import android.graphics.SweepGradient;
+import android.util.AttributeSet;
+import android.util.Xml;
+import androidx.core.R;
+import java.io.IOException;
+import java.util.List;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+/* loaded from: classes.dex */
+final class GradientColorInflaterCompat {
+    private static final int TILE_MODE_CLAMP = 0;
+    private static final int TILE_MODE_MIRROR = 2;
+    private static final int TILE_MODE_REPEAT = 1;
+
+    private GradientColorInflaterCompat() {
+    }
+
+    static Shader createFromXml(Resources resources, XmlPullParser xmlPullParser, Resources.Theme theme) throws XmlPullParserException, IOException {
+        int next;
+        AttributeSet asAttributeSet = Xml.asAttributeSet(xmlPullParser);
+        do {
+            next = xmlPullParser.next();
+            if (next == 2) {
+                break;
+            }
+        } while (next != 1);
+        if (next != 2) {
+            throw new XmlPullParserException("No start tag found");
+        }
+        return createFromXmlInner(resources, xmlPullParser, asAttributeSet, theme);
+    }
+
+    static Shader createFromXmlInner(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) throws IOException, XmlPullParserException {
+        String name = xmlPullParser.getName();
+        if (!name.equals("gradient")) {
+            throw new XmlPullParserException(xmlPullParser.getPositionDescription() + ": invalid gradient color tag " + name);
+        }
+        TypedArray obtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, R.styleable.GradientColor);
+        float namedFloat = TypedArrayUtils.getNamedFloat(obtainAttributes, xmlPullParser, "startX", R.styleable.GradientColor_android_startX, 0.0f);
+        float namedFloat2 = TypedArrayUtils.getNamedFloat(obtainAttributes, xmlPullParser, "startY", R.styleable.GradientColor_android_startY, 0.0f);
+        float namedFloat3 = TypedArrayUtils.getNamedFloat(obtainAttributes, xmlPullParser, "endX", R.styleable.GradientColor_android_endX, 0.0f);
+        float namedFloat4 = TypedArrayUtils.getNamedFloat(obtainAttributes, xmlPullParser, "endY", R.styleable.GradientColor_android_endY, 0.0f);
+        float namedFloat5 = TypedArrayUtils.getNamedFloat(obtainAttributes, xmlPullParser, "centerX", R.styleable.GradientColor_android_centerX, 0.0f);
+        float namedFloat6 = TypedArrayUtils.getNamedFloat(obtainAttributes, xmlPullParser, "centerY", R.styleable.GradientColor_android_centerY, 0.0f);
+        int namedInt = TypedArrayUtils.getNamedInt(obtainAttributes, xmlPullParser, "type", R.styleable.GradientColor_android_type, 0);
+        int namedColor = TypedArrayUtils.getNamedColor(obtainAttributes, xmlPullParser, "startColor", R.styleable.GradientColor_android_startColor, 0);
+        boolean hasAttribute = TypedArrayUtils.hasAttribute(xmlPullParser, "centerColor");
+        int namedColor2 = TypedArrayUtils.getNamedColor(obtainAttributes, xmlPullParser, "centerColor", R.styleable.GradientColor_android_centerColor, 0);
+        int namedColor3 = TypedArrayUtils.getNamedColor(obtainAttributes, xmlPullParser, "endColor", R.styleable.GradientColor_android_endColor, 0);
+        int namedInt2 = TypedArrayUtils.getNamedInt(obtainAttributes, xmlPullParser, "tileMode", R.styleable.GradientColor_android_tileMode, 0);
+        float namedFloat7 = TypedArrayUtils.getNamedFloat(obtainAttributes, xmlPullParser, "gradientRadius", R.styleable.GradientColor_android_gradientRadius, 0.0f);
+        obtainAttributes.recycle();
+        ColorStops checkColors = checkColors(inflateChildElements(resources, xmlPullParser, attributeSet, theme), namedColor, namedColor3, hasAttribute, namedColor2);
+        if (namedInt != 1) {
+            if (namedInt == 2) {
+                return new SweepGradient(namedFloat5, namedFloat6, checkColors.mColors, checkColors.mOffsets);
+            }
+            return new LinearGradient(namedFloat, namedFloat2, namedFloat3, namedFloat4, checkColors.mColors, checkColors.mOffsets, parseTileMode(namedInt2));
+        }
+        if (namedFloat7 <= 0.0f) {
+            throw new XmlPullParserException("<gradient> tag requires 'gradientRadius' attribute with radial type");
+        }
+        return new RadialGradient(namedFloat5, namedFloat6, namedFloat7, checkColors.mColors, checkColors.mOffsets, parseTileMode(namedInt2));
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:31:0x0084, code lost:
+    
+        throw new org.xmlpull.v1.XmlPullParserException(r9.getPositionDescription() + ": <item> tag requires a 'color' attribute and a 'offset' attribute!");
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static androidx.core.content.res.GradientColorInflaterCompat.ColorStops inflateChildElements(android.content.res.Resources r8, org.xmlpull.v1.XmlPullParser r9, android.util.AttributeSet r10, android.content.res.Resources.Theme r11) throws org.xmlpull.v1.XmlPullParserException, java.io.IOException {
+        /*
+            int r0 = r9.getDepth()
+            r1 = 1
+            int r0 = r0 + r1
+            java.util.ArrayList r2 = new java.util.ArrayList
+            r3 = 20
+            r2.<init>(r3)
+            java.util.ArrayList r4 = new java.util.ArrayList
+            r4.<init>(r3)
+        L12:
+            int r3 = r9.next()
+            if (r3 == r1) goto L85
+            int r5 = r9.getDepth()
+            if (r5 >= r0) goto L21
+            r6 = 3
+            if (r3 == r6) goto L85
+        L21:
+            r6 = 2
+            if (r3 == r6) goto L25
+            goto L12
+        L25:
+            if (r5 > r0) goto L12
+            java.lang.String r3 = r9.getName()
+            java.lang.String r5 = "item"
+            boolean r3 = r3.equals(r5)
+            if (r3 != 0) goto L34
+            goto L12
+        L34:
+            int[] r3 = androidx.core.R.styleable.GradientColorItem
+            android.content.res.TypedArray r3 = androidx.core.content.res.TypedArrayUtils.obtainAttributes(r8, r11, r10, r3)
+            int r5 = androidx.core.R.styleable.GradientColorItem_android_color
+            boolean r5 = r3.hasValue(r5)
+            int r6 = androidx.core.R.styleable.GradientColorItem_android_offset
+            boolean r6 = r3.hasValue(r6)
+            if (r5 == 0) goto L6a
+            if (r6 == 0) goto L6a
+            int r5 = androidx.core.R.styleable.GradientColorItem_android_color
+            r6 = 0
+            int r5 = r3.getColor(r5, r6)
+            int r6 = androidx.core.R.styleable.GradientColorItem_android_offset
+            r7 = 0
+            float r6 = r3.getFloat(r6, r7)
+            r3.recycle()
+            java.lang.Integer r3 = java.lang.Integer.valueOf(r5)
+            r4.add(r3)
+            java.lang.Float r3 = java.lang.Float.valueOf(r6)
+            r2.add(r3)
+            goto L12
+        L6a:
+            org.xmlpull.v1.XmlPullParserException r8 = new org.xmlpull.v1.XmlPullParserException
+            java.lang.StringBuilder r10 = new java.lang.StringBuilder
+            r10.<init>()
+            java.lang.String r9 = r9.getPositionDescription()
+            r10.append(r9)
+            java.lang.String r9 = ": <item> tag requires a 'color' attribute and a 'offset' attribute!"
+            r10.append(r9)
+            java.lang.String r9 = r10.toString()
+            r8.<init>(r9)
+            throw r8
+        L85:
+            int r8 = r4.size()
+            if (r8 <= 0) goto L91
+            androidx.core.content.res.GradientColorInflaterCompat$ColorStops r8 = new androidx.core.content.res.GradientColorInflaterCompat$ColorStops
+            r8.<init>(r4, r2)
+            return r8
+        L91:
+            r8 = 0
+            return r8
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.core.content.res.GradientColorInflaterCompat.inflateChildElements(android.content.res.Resources, org.xmlpull.v1.XmlPullParser, android.util.AttributeSet, android.content.res.Resources$Theme):androidx.core.content.res.GradientColorInflaterCompat$ColorStops");
+    }
+
+    private static ColorStops checkColors(ColorStops colorStops, int i, int i2, boolean z, int i3) {
+        if (colorStops != null) {
+            return colorStops;
+        }
+        if (z) {
+            return new ColorStops(i, i3, i2);
+        }
+        return new ColorStops(i, i2);
+    }
+
+    private static Shader.TileMode parseTileMode(int i) {
+        if (i == 1) {
+            return Shader.TileMode.REPEAT;
+        }
+        if (i == 2) {
+            return Shader.TileMode.MIRROR;
+        }
+        return Shader.TileMode.CLAMP;
+    }
+
+    static final class ColorStops {
+        final int[] mColors;
+        final float[] mOffsets;
+
+        ColorStops(List<Integer> list, List<Float> list2) {
+            int size = list.size();
+            this.mColors = new int[size];
+            this.mOffsets = new float[size];
+            for (int i = 0; i < size; i++) {
+                this.mColors[i] = list.get(i).intValue();
+                this.mOffsets[i] = list2.get(i).floatValue();
+            }
+        }
+
+        ColorStops(int i, int i2) {
+            this.mColors = new int[]{i, i2};
+            this.mOffsets = new float[]{0.0f, 1.0f};
+        }
+
+        ColorStops(int i, int i2, int i3) {
+            this.mColors = new int[]{i, i2, i3};
+            this.mOffsets = new float[]{0.0f, 0.5f, 1.0f};
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/res/GrowingArrayUtils.java

@@ -0,0 +1,110 @@
+package androidx.core.content.res;
+
+import java.lang.reflect.Array;
+
+/* loaded from: classes.dex */
+final class GrowingArrayUtils {
+    public static int growSize(int i) {
+        if (i <= 4) {
+            return 8;
+        }
+        return i * 2;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v4, types: [java.lang.Object, java.lang.Object[]] */
+    public static <T> T[] append(T[] tArr, int i, T t) {
+        if (i + 1 > tArr.length) {
+            ?? r0 = (Object[]) Array.newInstance(tArr.getClass().getComponentType(), growSize(i));
+            System.arraycopy(tArr, 0, r0, 0, i);
+            tArr = r0;
+        }
+        tArr[i] = t;
+        return tArr;
+    }
+
+    public static int[] append(int[] iArr, int i, int i2) {
+        if (i + 1 > iArr.length) {
+            int[] iArr2 = new int[growSize(i)];
+            System.arraycopy(iArr, 0, iArr2, 0, i);
+            iArr = iArr2;
+        }
+        iArr[i] = i2;
+        return iArr;
+    }
+
+    public static long[] append(long[] jArr, int i, long j) {
+        if (i + 1 > jArr.length) {
+            long[] jArr2 = new long[growSize(i)];
+            System.arraycopy(jArr, 0, jArr2, 0, i);
+            jArr = jArr2;
+        }
+        jArr[i] = j;
+        return jArr;
+    }
+
+    public static boolean[] append(boolean[] zArr, int i, boolean z) {
+        if (i + 1 > zArr.length) {
+            boolean[] zArr2 = new boolean[growSize(i)];
+            System.arraycopy(zArr, 0, zArr2, 0, i);
+            zArr = zArr2;
+        }
+        zArr[i] = z;
+        return zArr;
+    }
+
+    public static <T> T[] insert(T[] tArr, int i, int i2, T t) {
+        if (i + 1 <= tArr.length) {
+            System.arraycopy(tArr, i2, tArr, i2 + 1, i - i2);
+            tArr[i2] = t;
+            return tArr;
+        }
+        T[] tArr2 = (T[]) ((Object[]) Array.newInstance(tArr.getClass().getComponentType(), growSize(i)));
+        System.arraycopy(tArr, 0, tArr2, 0, i2);
+        tArr2[i2] = t;
+        System.arraycopy(tArr, i2, tArr2, i2 + 1, tArr.length - i2);
+        return tArr2;
+    }
+
+    public static int[] insert(int[] iArr, int i, int i2, int i3) {
+        if (i + 1 <= iArr.length) {
+            System.arraycopy(iArr, i2, iArr, i2 + 1, i - i2);
+            iArr[i2] = i3;
+            return iArr;
+        }
+        int[] iArr2 = new int[growSize(i)];
+        System.arraycopy(iArr, 0, iArr2, 0, i2);
+        iArr2[i2] = i3;
+        System.arraycopy(iArr, i2, iArr2, i2 + 1, iArr.length - i2);
+        return iArr2;
+    }
+
+    public static long[] insert(long[] jArr, int i, int i2, long j) {
+        if (i + 1 <= jArr.length) {
+            System.arraycopy(jArr, i2, jArr, i2 + 1, i - i2);
+            jArr[i2] = j;
+            return jArr;
+        }
+        long[] jArr2 = new long[growSize(i)];
+        System.arraycopy(jArr, 0, jArr2, 0, i2);
+        jArr2[i2] = j;
+        System.arraycopy(jArr, i2, jArr2, i2 + 1, jArr.length - i2);
+        return jArr2;
+    }
+
+    public static boolean[] insert(boolean[] zArr, int i, int i2, boolean z) {
+        if (i + 1 <= zArr.length) {
+            System.arraycopy(zArr, i2, zArr, i2 + 1, i - i2);
+            zArr[i2] = z;
+            return zArr;
+        }
+        boolean[] zArr2 = new boolean[growSize(i)];
+        System.arraycopy(zArr, 0, zArr2, 0, i2);
+        zArr2[i2] = z;
+        System.arraycopy(zArr, i2, zArr2, i2 + 1, zArr.length - i2);
+        return zArr2;
+    }
+
+    private GrowingArrayUtils() {
+    }
+}

02-Easy5/E5/sources/androidx/core/content/res/ResourcesCompat.java

@@ -0,0 +1,473 @@
+package androidx.core.content.res;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.graphics.Typeface;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import android.util.SparseArray;
+import android.util.TypedValue;
+import androidx.core.content.res.ResourcesCompat;
+import androidx.core.util.ObjectsCompat;
+import androidx.core.util.Preconditions;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Iterator;
+import java.util.WeakHashMap;
+
+/* loaded from: classes.dex */
+public final class ResourcesCompat {
+    public static final int ID_NULL = 0;
+    private static final String TAG = "ResourcesCompat";
+    private static final ThreadLocal<TypedValue> sTempTypedValue = new ThreadLocal<>();
+    private static final WeakHashMap<ColorStateListCacheKey, SparseArray<ColorStateListCacheEntry>> sColorStateCaches = new WeakHashMap<>(0);
+    private static final Object sColorStateCacheLock = new Object();
+
+    public static void clearCachesForTheme(Resources.Theme theme) {
+        synchronized (sColorStateCacheLock) {
+            Iterator<ColorStateListCacheKey> it = sColorStateCaches.keySet().iterator();
+            while (it.hasNext()) {
+                ColorStateListCacheKey next = it.next();
+                if (next != null && theme.equals(next.mTheme)) {
+                    it.remove();
+                }
+            }
+        }
+    }
+
+    public static Drawable getDrawable(Resources resources, int i, Resources.Theme theme) throws Resources.NotFoundException {
+        return Api21Impl.getDrawable(resources, i, theme);
+    }
+
+    public static Drawable getDrawableForDensity(Resources resources, int i, int i2, Resources.Theme theme) throws Resources.NotFoundException {
+        return Api21Impl.getDrawableForDensity(resources, i, i2, theme);
+    }
+
+    public static int getColor(Resources resources, int i, Resources.Theme theme) throws Resources.NotFoundException {
+        if (Build.VERSION.SDK_INT >= 23) {
+            return Api23Impl.getColor(resources, i, theme);
+        }
+        return resources.getColor(i);
+    }
+
+    public static ColorStateList getColorStateList(Resources resources, int i, Resources.Theme theme) throws Resources.NotFoundException {
+        ColorStateListCacheKey colorStateListCacheKey = new ColorStateListCacheKey(resources, theme);
+        ColorStateList cachedColorStateList = getCachedColorStateList(colorStateListCacheKey, i);
+        if (cachedColorStateList != null) {
+            return cachedColorStateList;
+        }
+        ColorStateList inflateColorStateList = inflateColorStateList(resources, i, theme);
+        if (inflateColorStateList != null) {
+            addColorStateListToCache(colorStateListCacheKey, i, inflateColorStateList, theme);
+            return inflateColorStateList;
+        }
+        if (Build.VERSION.SDK_INT >= 23) {
+            return Api23Impl.getColorStateList(resources, i, theme);
+        }
+        return resources.getColorStateList(i);
+    }
+
+    private static ColorStateList inflateColorStateList(Resources resources, int i, Resources.Theme theme) {
+        if (isColorInt(resources, i)) {
+            return null;
+        }
+        try {
+            return ColorStateListInflaterCompat.createFromXml(resources, resources.getXml(i), theme);
+        } catch (Exception e) {
+            Log.w(TAG, "Failed to inflate ColorStateList, leaving it to the framework", e);
+            return null;
+        }
+    }
+
+    private static ColorStateList getCachedColorStateList(ColorStateListCacheKey colorStateListCacheKey, int i) {
+        ColorStateListCacheEntry colorStateListCacheEntry;
+        synchronized (sColorStateCacheLock) {
+            SparseArray<ColorStateListCacheEntry> sparseArray = sColorStateCaches.get(colorStateListCacheKey);
+            if (sparseArray != null && sparseArray.size() > 0 && (colorStateListCacheEntry = sparseArray.get(i)) != null) {
+                if (colorStateListCacheEntry.mConfiguration.equals(colorStateListCacheKey.mResources.getConfiguration()) && ((colorStateListCacheKey.mTheme == null && colorStateListCacheEntry.mThemeHash == 0) || (colorStateListCacheKey.mTheme != null && colorStateListCacheEntry.mThemeHash == colorStateListCacheKey.mTheme.hashCode()))) {
+                    return colorStateListCacheEntry.mValue;
+                }
+                sparseArray.remove(i);
+            }
+            return null;
+        }
+    }
+
+    private static void addColorStateListToCache(ColorStateListCacheKey colorStateListCacheKey, int i, ColorStateList colorStateList, Resources.Theme theme) {
+        synchronized (sColorStateCacheLock) {
+            WeakHashMap<ColorStateListCacheKey, SparseArray<ColorStateListCacheEntry>> weakHashMap = sColorStateCaches;
+            SparseArray<ColorStateListCacheEntry> sparseArray = weakHashMap.get(colorStateListCacheKey);
+            if (sparseArray == null) {
+                sparseArray = new SparseArray<>();
+                weakHashMap.put(colorStateListCacheKey, sparseArray);
+            }
+            sparseArray.append(i, new ColorStateListCacheEntry(colorStateList, colorStateListCacheKey.mResources.getConfiguration(), theme));
+        }
+    }
+
+    private static boolean isColorInt(Resources resources, int i) {
+        TypedValue typedValue = getTypedValue();
+        resources.getValue(i, typedValue, true);
+        return typedValue.type >= 28 && typedValue.type <= 31;
+    }
+
+    private static TypedValue getTypedValue() {
+        ThreadLocal<TypedValue> threadLocal = sTempTypedValue;
+        TypedValue typedValue = threadLocal.get();
+        if (typedValue != null) {
+            return typedValue;
+        }
+        TypedValue typedValue2 = new TypedValue();
+        threadLocal.set(typedValue2);
+        return typedValue2;
+    }
+
+    private static final class ColorStateListCacheKey {
+        final Resources mResources;
+        final Resources.Theme mTheme;
+
+        ColorStateListCacheKey(Resources resources, Resources.Theme theme) {
+            this.mResources = resources;
+            this.mTheme = theme;
+        }
+
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (obj == null || getClass() != obj.getClass()) {
+                return false;
+            }
+            ColorStateListCacheKey colorStateListCacheKey = (ColorStateListCacheKey) obj;
+            return this.mResources.equals(colorStateListCacheKey.mResources) && ObjectsCompat.equals(this.mTheme, colorStateListCacheKey.mTheme);
+        }
+
+        public int hashCode() {
+            return ObjectsCompat.hash(this.mResources, this.mTheme);
+        }
+    }
+
+    private static class ColorStateListCacheEntry {
+        final Configuration mConfiguration;
+        final int mThemeHash;
+        final ColorStateList mValue;
+
+        ColorStateListCacheEntry(ColorStateList colorStateList, Configuration configuration, Resources.Theme theme) {
+            this.mValue = colorStateList;
+            this.mConfiguration = configuration;
+            this.mThemeHash = theme == null ? 0 : theme.hashCode();
+        }
+    }
+
+    public static float getFloat(Resources resources, int i) {
+        if (Build.VERSION.SDK_INT >= 29) {
+            return Api29Impl.getFloat(resources, i);
+        }
+        TypedValue typedValue = getTypedValue();
+        resources.getValue(i, typedValue, true);
+        if (typedValue.type == 4) {
+            return typedValue.getFloat();
+        }
+        throw new Resources.NotFoundException("Resource ID #0x" + Integer.toHexString(i) + " type #0x" + Integer.toHexString(typedValue.type) + " is not valid");
+    }
+
+    public static Typeface getFont(Context context, int i) throws Resources.NotFoundException {
+        if (context.isRestricted()) {
+            return null;
+        }
+        return loadFont(context, i, new TypedValue(), 0, null, null, false, false);
+    }
+
+    public static Typeface getCachedFont(Context context, int i) throws Resources.NotFoundException {
+        if (context.isRestricted()) {
+            return null;
+        }
+        return loadFont(context, i, new TypedValue(), 0, null, null, false, true);
+    }
+
+    public static abstract class FontCallback {
+        /* renamed from: onFontRetrievalFailed, reason: merged with bridge method [inline-methods] */
+        public abstract void m80xb24343b7(int i);
+
+        /* renamed from: onFontRetrieved, reason: merged with bridge method [inline-methods] */
+        public abstract void m81x46c88379(Typeface typeface);
+
+        public final void callbackSuccessAsync(final Typeface typeface, Handler handler) {
+            getHandler(handler).post(new Runnable() { // from class: androidx.core.content.res.ResourcesCompat$FontCallback$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    ResourcesCompat.FontCallback.this.m81x46c88379(typeface);
+                }
+            });
+        }
+
+        public final void callbackFailAsync(final int i, Handler handler) {
+            getHandler(handler).post(new Runnable() { // from class: androidx.core.content.res.ResourcesCompat$FontCallback$$ExternalSyntheticLambda1
+                @Override // java.lang.Runnable
+                public final void run() {
+                    ResourcesCompat.FontCallback.this.m80xb24343b7(i);
+                }
+            });
+        }
+
+        public static Handler getHandler(Handler handler) {
+            return handler == null ? new Handler(Looper.getMainLooper()) : handler;
+        }
+    }
+
+    public static void getFont(Context context, int i, FontCallback fontCallback, Handler handler) throws Resources.NotFoundException {
+        Preconditions.checkNotNull(fontCallback);
+        if (context.isRestricted()) {
+            fontCallback.callbackFailAsync(-4, handler);
+        } else {
+            loadFont(context, i, new TypedValue(), 0, fontCallback, handler, false, false);
+        }
+    }
+
+    public static Typeface getFont(Context context, int i, TypedValue typedValue, int i2, FontCallback fontCallback) throws Resources.NotFoundException {
+        if (context.isRestricted()) {
+            return null;
+        }
+        return loadFont(context, i, typedValue, i2, fontCallback, null, true, false);
+    }
+
+    private static Typeface loadFont(Context context, int i, TypedValue typedValue, int i2, FontCallback fontCallback, Handler handler, boolean z, boolean z2) {
+        Resources resources = context.getResources();
+        resources.getValue(i, typedValue, true);
+        Typeface loadFont = loadFont(context, resources, typedValue, i, i2, fontCallback, handler, z, z2);
+        if (loadFont != null || fontCallback != null || z2) {
+            return loadFont;
+        }
+        throw new Resources.NotFoundException("Font resource ID #0x" + Integer.toHexString(i) + " could not be retrieved.");
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:36:0x00b3  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static android.graphics.Typeface loadFont(android.content.Context r17, android.content.res.Resources r18, android.util.TypedValue r19, int r20, int r21, androidx.core.content.res.ResourcesCompat.FontCallback r22, android.os.Handler r23, boolean r24, boolean r25) {
+        /*
+            r0 = r18
+            r1 = r19
+            r4 = r20
+            r11 = r22
+            r12 = r23
+            java.lang.String r13 = "ResourcesCompat"
+            java.lang.CharSequence r2 = r1.string
+            if (r2 == 0) goto Lb7
+            java.lang.CharSequence r2 = r1.string
+            java.lang.String r14 = r2.toString()
+            java.lang.String r2 = "res/"
+            boolean r2 = r14.startsWith(r2)
+            r15 = -3
+            r16 = 0
+            if (r2 != 0) goto L27
+            if (r11 == 0) goto L26
+            r11.callbackFailAsync(r15, r12)
+        L26:
+            return r16
+        L27:
+            int r2 = r1.assetCookie
+            r7 = r21
+            android.graphics.Typeface r2 = androidx.core.graphics.TypefaceCompat.findFromCache(r0, r4, r14, r2, r7)
+            if (r2 == 0) goto L37
+            if (r11 == 0) goto L36
+            r11.callbackSuccessAsync(r2, r12)
+        L36:
+            return r2
+        L37:
+            if (r25 == 0) goto L3a
+            return r16
+        L3a:
+            java.lang.String r2 = r14.toLowerCase()     // Catch: java.io.IOException -> L8c org.xmlpull.v1.XmlPullParserException -> L9f
+            java.lang.String r3 = ".xml"
+            boolean r2 = r2.endsWith(r3)     // Catch: java.io.IOException -> L8c org.xmlpull.v1.XmlPullParserException -> L9f
+            if (r2 == 0) goto L71
+            android.content.res.XmlResourceParser r2 = r0.getXml(r4)     // Catch: java.io.IOException -> L8c org.xmlpull.v1.XmlPullParserException -> L9f
+            androidx.core.content.res.FontResourcesParserCompat$FamilyResourceEntry r2 = androidx.core.content.res.FontResourcesParserCompat.parse(r2, r0)     // Catch: java.io.IOException -> L8c org.xmlpull.v1.XmlPullParserException -> L9f
+            if (r2 != 0) goto L5b
+            java.lang.String r0 = "Failed to find font-family tag"
+            android.util.Log.e(r13, r0)     // Catch: java.io.IOException -> L8c org.xmlpull.v1.XmlPullParserException -> L9f
+            if (r11 == 0) goto L5a
+            r11.callbackFailAsync(r15, r12)     // Catch: java.io.IOException -> L8c org.xmlpull.v1.XmlPullParserException -> L9f
+        L5a:
+            return r16
+        L5b:
+            int r6 = r1.assetCookie     // Catch: java.io.IOException -> L8c org.xmlpull.v1.XmlPullParserException -> L9f
+            r1 = r17
+            r3 = r18
+            r4 = r20
+            r5 = r14
+            r7 = r21
+            r8 = r22
+            r9 = r23
+            r10 = r24
+            android.graphics.Typeface r0 = androidx.core.graphics.TypefaceCompat.createFromResourcesFamilyXml(r1, r2, r3, r4, r5, r6, r7, r8, r9, r10)     // Catch: java.io.IOException -> L8c org.xmlpull.v1.XmlPullParserException -> L9f
+            return r0
+        L71:
+            int r5 = r1.assetCookie     // Catch: java.io.IOException -> L8c org.xmlpull.v1.XmlPullParserException -> L9f
+            r1 = r17
+            r2 = r18
+            r3 = r20
+            r4 = r14
+            r6 = r21
+            android.graphics.Typeface r0 = androidx.core.graphics.TypefaceCompat.createFromResourcesFontFile(r1, r2, r3, r4, r5, r6)     // Catch: java.io.IOException -> L8c org.xmlpull.v1.XmlPullParserException -> L9f
+            if (r11 == 0) goto L8b
+            if (r0 == 0) goto L88
+            r11.callbackSuccessAsync(r0, r12)     // Catch: java.io.IOException -> L8c org.xmlpull.v1.XmlPullParserException -> L9f
+            goto L8b
+        L88:
+            r11.callbackFailAsync(r15, r12)     // Catch: java.io.IOException -> L8c org.xmlpull.v1.XmlPullParserException -> L9f
+        L8b:
+            return r0
+        L8c:
+            r0 = move-exception
+            java.lang.StringBuilder r1 = new java.lang.StringBuilder
+            java.lang.String r2 = "Failed to read xml resource "
+            r1.<init>(r2)
+            r1.append(r14)
+            java.lang.String r1 = r1.toString()
+            android.util.Log.e(r13, r1, r0)
+            goto Lb1
+        L9f:
+            r0 = move-exception
+            java.lang.StringBuilder r1 = new java.lang.StringBuilder
+            java.lang.String r2 = "Failed to parse xml resource "
+            r1.<init>(r2)
+            r1.append(r14)
+            java.lang.String r1 = r1.toString()
+            android.util.Log.e(r13, r1, r0)
+        Lb1:
+            if (r11 == 0) goto Lb6
+            r11.callbackFailAsync(r15, r12)
+        Lb6:
+            return r16
+        Lb7:
+            android.content.res.Resources$NotFoundException r2 = new android.content.res.Resources$NotFoundException
+            java.lang.StringBuilder r3 = new java.lang.StringBuilder
+            java.lang.String r5 = "Resource \""
+            r3.<init>(r5)
+            java.lang.String r0 = r0.getResourceName(r4)
+            r3.append(r0)
+            java.lang.String r0 = "\" ("
+            r3.append(r0)
+            java.lang.String r0 = java.lang.Integer.toHexString(r20)
+            r3.append(r0)
+            java.lang.String r0 = ") is not a Font: "
+            r3.append(r0)
+            r3.append(r1)
+            java.lang.String r0 = r3.toString()
+            r2.<init>(r0)
+            throw r2
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.core.content.res.ResourcesCompat.loadFont(android.content.Context, android.content.res.Resources, android.util.TypedValue, int, int, androidx.core.content.res.ResourcesCompat$FontCallback, android.os.Handler, boolean, boolean):android.graphics.Typeface");
+    }
+
+    static class Api29Impl {
+        private Api29Impl() {
+        }
+
+        static float getFloat(Resources resources, int i) {
+            return resources.getFloat(i);
+        }
+    }
+
+    static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        static ColorStateList getColorStateList(Resources resources, int i, Resources.Theme theme) {
+            return resources.getColorStateList(i, theme);
+        }
+
+        static int getColor(Resources resources, int i, Resources.Theme theme) {
+            return resources.getColor(i, theme);
+        }
+    }
+
+    static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        static Drawable getDrawable(Resources resources, int i, Resources.Theme theme) {
+            return resources.getDrawable(i, theme);
+        }
+
+        static Drawable getDrawableForDensity(Resources resources, int i, int i2, Resources.Theme theme) {
+            return resources.getDrawableForDensity(i, i2, theme);
+        }
+    }
+
+    static class Api15Impl {
+        private Api15Impl() {
+        }
+
+        static Drawable getDrawableForDensity(Resources resources, int i, int i2) {
+            return resources.getDrawableForDensity(i, i2);
+        }
+    }
+
+    private ResourcesCompat() {
+    }
+
+    public static final class ThemeCompat {
+        private ThemeCompat() {
+        }
+
+        public static void rebase(Resources.Theme theme) {
+            if (Build.VERSION.SDK_INT >= 29) {
+                Api29Impl.rebase(theme);
+            } else if (Build.VERSION.SDK_INT >= 23) {
+                Api23Impl.rebase(theme);
+            }
+        }
+
+        static class Api29Impl {
+            private Api29Impl() {
+            }
+
+            static void rebase(Resources.Theme theme) {
+                theme.rebase();
+            }
+        }
+
+        static class Api23Impl {
+            private static Method sRebaseMethod;
+            private static boolean sRebaseMethodFetched;
+            private static final Object sRebaseMethodLock = new Object();
+
+            private Api23Impl() {
+            }
+
+            static void rebase(Resources.Theme theme) {
+                synchronized (sRebaseMethodLock) {
+                    if (!sRebaseMethodFetched) {
+                        try {
+                            Method declaredMethod = Resources.Theme.class.getDeclaredMethod("rebase", new Class[0]);
+                            sRebaseMethod = declaredMethod;
+                            declaredMethod.setAccessible(true);
+                        } catch (NoSuchMethodException e) {
+                            Log.i(ResourcesCompat.TAG, "Failed to retrieve rebase() method", e);
+                        }
+                        sRebaseMethodFetched = true;
+                    }
+                    Method method = sRebaseMethod;
+                    if (method != null) {
+                        try {
+                            method.invoke(theme, new Object[0]);
+                        } catch (IllegalAccessException | InvocationTargetException e2) {
+                            Log.i(ResourcesCompat.TAG, "Failed to invoke rebase() method via reflection", e2);
+                            sRebaseMethod = null;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

02-Easy5/E5/sources/androidx/core/content/res/TypedArrayApi26ImplKt.java

@@ -0,0 +1,25 @@
+package androidx.core.content.res;
+
+import android.content.res.TypedArray;
+import android.graphics.Typeface;
+import kotlin.Metadata;
+import kotlin.jvm.JvmStatic;
+import kotlin.jvm.internal.Intrinsics;
+
+/* compiled from: TypedArray.kt */
+@Metadata(d1 = {"\u0000\u001e\n\u0002\u0018\u0002\n\u0002\u0010\u0000\n\u0002\b\u0002\n\u0002\u0018\u0002\n\u0000\n\u0002\u0018\u0002\n\u0000\n\u0002\u0010\b\n\u0000\bÃ\u0002\u0018\u00002\u00020\u0001B\u0007\b\u0002¢\u0006\u0002\u0010\u0002J\u001a\u0010\u0003\u001a\u00020\u00042\u0006\u0010\u0005\u001a\u00020\u00062\b\b\u0001\u0010\u0007\u001a\u00020\bH\u0007¨\u0006\t"}, d2 = {"Landroidx/core/content/res/TypedArrayApi26ImplKt;", "", "()V", "getFont", "Landroid/graphics/Typeface;", "typedArray", "Landroid/content/res/TypedArray;", "index", "", "core-ktx_release"}, k = 1, mv = {1, 7, 1}, xi = 48)
+/* loaded from: classes.dex */
+final class TypedArrayApi26ImplKt {
+    public static final TypedArrayApi26ImplKt INSTANCE = new TypedArrayApi26ImplKt();
+
+    private TypedArrayApi26ImplKt() {
+    }
+
+    @JvmStatic
+    public static final Typeface getFont(TypedArray typedArray, int index) {
+        Intrinsics.checkNotNullParameter(typedArray, "typedArray");
+        Typeface font = typedArray.getFont(index);
+        Intrinsics.checkNotNull(font);
+        return font;
+    }
+}

02-Easy5/E5/sources/androidx/core/content/res/TypedArrayKt.java

@@ -0,0 +1,134 @@
+package androidx.core.content.res;
+
+import android.content.res.ColorStateList;
+import android.content.res.TypedArray;
+import android.graphics.Typeface;
+import android.graphics.drawable.Drawable;
+import kotlin.Metadata;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* compiled from: TypedArray.kt */
+@Metadata(d1 = {"\u0000R\n\u0000\n\u0002\u0010\u0002\n\u0002\u0018\u0002\n\u0000\n\u0002\u0010\b\n\u0000\n\u0002\u0010\u000b\n\u0002\b\u0002\n\u0002\u0018\u0002\n\u0000\n\u0002\u0010\u0007\n\u0002\b\u0003\n\u0002\u0018\u0002\n\u0002\b\u0002\n\u0002\u0018\u0002\n\u0002\b\u0004\n\u0002\u0010\u000e\n\u0000\n\u0002\u0010\u0011\n\u0002\u0010\r\n\u0002\b\u0005\n\u0002\u0018\u0002\n\u0002\b\u0002\u001a\u0016\u0010\u0000\u001a\u00020\u0001*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004H\u0002\u001a\u0014\u0010\u0005\u001a\u00020\u0006*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004\u001a\u0016\u0010\u0007\u001a\u00020\u0004*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004H\u0007\u001a\u0014\u0010\b\u001a\u00020\t*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004\u001a\u0014\u0010\n\u001a\u00020\u000b*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004\u001a\u0016\u0010\f\u001a\u00020\u0004*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004H\u0007\u001a\u0016\u0010\r\u001a\u00020\u0004*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004H\u0007\u001a\u0014\u0010\u000e\u001a\u00020\u000f*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004\u001a\u0014\u0010\u0010\u001a\u00020\u000b*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004\u001a\u0016\u0010\u0011\u001a\u00020\u0012*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004H\u0007\u001a\u0014\u0010\u0013\u001a\u00020\u0004*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004\u001a\u0014\u0010\u0014\u001a\u00020\u0004*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004\u001a\u0016\u0010\u0015\u001a\u00020\u0004*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004H\u0007\u001a\u0014\u0010\u0016\u001a\u00020\u0017*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004\u001a\u001f\u0010\u0018\u001a\b\u0012\u0004\u0012\u00020\u001a0\u0019*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004¢\u0006\u0002\u0010\u001b\u001a\u0014\u0010\u001c\u001a\u00020\u001a*\u00020\u00022\b\b\u0001\u0010\u0003\u001a\u00020\u0004\u001a/\u0010\u001d\u001a\u0002H\u001e\"\u0004\b\u0000\u0010\u001e*\u00020\u00022\u0012\u0010\u001f\u001a\u000e\u0012\u0004\u0012\u00020\u0002\u0012\u0004\u0012\u0002H\u001e0 H\u0086\bø\u0001\u0000¢\u0006\u0002\u0010!\u0082\u0002\u0007\n\u0005\b\u009920\u0001¨\u0006\""}, d2 = {"checkAttribute", "", "Landroid/content/res/TypedArray;", "index", "", "getBooleanOrThrow", "", "getColorOrThrow", "getColorStateListOrThrow", "Landroid/content/res/ColorStateList;", "getDimensionOrThrow", "", "getDimensionPixelOffsetOrThrow", "getDimensionPixelSizeOrThrow", "getDrawableOrThrow", "Landroid/graphics/drawable/Drawable;", "getFloatOrThrow", "getFontOrThrow", "Landroid/graphics/Typeface;", "getIntOrThrow", "getIntegerOrThrow", "getResourceIdOrThrow", "getStringOrThrow", "", "getTextArrayOrThrow", "", "", "(Landroid/content/res/TypedArray;I)[Ljava/lang/CharSequence;", "getTextOrThrow", "use", "R", "block", "Lkotlin/Function1;", "(Landroid/content/res/TypedArray;Lkotlin/jvm/functions/Function1;)Ljava/lang/Object;", "core-ktx_release"}, k = 2, mv = {1, 7, 1}, xi = 48)
+/* loaded from: classes.dex */
+public final class TypedArrayKt {
+    private static final void checkAttribute(TypedArray typedArray, int i) {
+        if (!typedArray.hasValue(i)) {
+            throw new IllegalArgumentException("Attribute not defined in set.");
+        }
+    }
+
+    public static final boolean getBooleanOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        return typedArray.getBoolean(i, false);
+    }
+
+    public static final int getColorOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        return typedArray.getColor(i, 0);
+    }
+
+    public static final ColorStateList getColorStateListOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        ColorStateList colorStateList = typedArray.getColorStateList(i);
+        if (colorStateList != null) {
+            return colorStateList;
+        }
+        throw new IllegalStateException("Attribute value was not a color or color state list.".toString());
+    }
+
+    public static final float getDimensionOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        return typedArray.getDimension(i, 0.0f);
+    }
+
+    public static final int getDimensionPixelOffsetOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        return typedArray.getDimensionPixelOffset(i, 0);
+    }
+
+    public static final int getDimensionPixelSizeOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        return typedArray.getDimensionPixelSize(i, 0);
+    }
+
+    public static final Drawable getDrawableOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        Drawable drawable = typedArray.getDrawable(i);
+        Intrinsics.checkNotNull(drawable);
+        return drawable;
+    }
+
+    public static final float getFloatOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        return typedArray.getFloat(i, 0.0f);
+    }
+
+    public static final Typeface getFontOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        return TypedArrayApi26ImplKt.getFont(typedArray, i);
+    }
+
+    public static final int getIntOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        return typedArray.getInt(i, 0);
+    }
+
+    public static final int getIntegerOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        return typedArray.getInteger(i, 0);
+    }
+
+    public static final int getResourceIdOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        return typedArray.getResourceId(i, 0);
+    }
+
+    public static final String getStringOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        String string = typedArray.getString(i);
+        if (string != null) {
+            return string;
+        }
+        throw new IllegalStateException("Attribute value could not be coerced to String.".toString());
+    }
+
+    public static final CharSequence getTextOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        CharSequence text = typedArray.getText(i);
+        if (text != null) {
+            return text;
+        }
+        throw new IllegalStateException("Attribute value could not be coerced to CharSequence.".toString());
+    }
+
+    public static final CharSequence[] getTextArrayOrThrow(TypedArray typedArray, int i) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        checkAttribute(typedArray, i);
+        CharSequence[] textArray = typedArray.getTextArray(i);
+        Intrinsics.checkNotNullExpressionValue(textArray, "getTextArray(index)");
+        return textArray;
+    }
+
+    public static final <R> R use(TypedArray typedArray, Function1<? super TypedArray, ? extends R> block) {
+        Intrinsics.checkNotNullParameter(typedArray, "<this>");
+        Intrinsics.checkNotNullParameter(block, "block");
+        R invoke = block.invoke(typedArray);
+        typedArray.recycle();
+        return invoke;
+    }
+}

02-Easy5/E5/sources/androidx/core/content/res/TypedArrayUtils.java

@@ -0,0 +1,135 @@
+package androidx.core.content.res;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import android.util.TypedValue;
+import org.xmlpull.v1.XmlPullParser;
+
+/* loaded from: classes.dex */
+public class TypedArrayUtils {
+    private static final String NAMESPACE = "http://schemas.android.com/apk/res/android";
+
+    public static boolean hasAttribute(XmlPullParser xmlPullParser, String str) {
+        return xmlPullParser.getAttributeValue(NAMESPACE, str) != null;
+    }
+
+    public static float getNamedFloat(TypedArray typedArray, XmlPullParser xmlPullParser, String str, int i, float f) {
+        return !hasAttribute(xmlPullParser, str) ? f : typedArray.getFloat(i, f);
+    }
+
+    public static boolean getNamedBoolean(TypedArray typedArray, XmlPullParser xmlPullParser, String str, int i, boolean z) {
+        return !hasAttribute(xmlPullParser, str) ? z : typedArray.getBoolean(i, z);
+    }
+
+    public static int getNamedInt(TypedArray typedArray, XmlPullParser xmlPullParser, String str, int i, int i2) {
+        return !hasAttribute(xmlPullParser, str) ? i2 : typedArray.getInt(i, i2);
+    }
+
+    public static int getNamedColor(TypedArray typedArray, XmlPullParser xmlPullParser, String str, int i, int i2) {
+        return !hasAttribute(xmlPullParser, str) ? i2 : typedArray.getColor(i, i2);
+    }
+
+    public static ComplexColorCompat getNamedComplexColor(TypedArray typedArray, XmlPullParser xmlPullParser, Resources.Theme theme, String str, int i, int i2) {
+        if (hasAttribute(xmlPullParser, str)) {
+            TypedValue typedValue = new TypedValue();
+            typedArray.getValue(i, typedValue);
+            if (typedValue.type >= 28 && typedValue.type <= 31) {
+                return ComplexColorCompat.from(typedValue.data);
+            }
+            ComplexColorCompat inflate = ComplexColorCompat.inflate(typedArray.getResources(), typedArray.getResourceId(i, 0), theme);
+            if (inflate != null) {
+                return inflate;
+            }
+        }
+        return ComplexColorCompat.from(i2);
+    }
+
+    public static ColorStateList getNamedColorStateList(TypedArray typedArray, XmlPullParser xmlPullParser, Resources.Theme theme, String str, int i) {
+        if (!hasAttribute(xmlPullParser, str)) {
+            return null;
+        }
+        TypedValue typedValue = new TypedValue();
+        typedArray.getValue(i, typedValue);
+        if (typedValue.type == 2) {
+            throw new UnsupportedOperationException("Failed to resolve attribute at index " + i + ": " + typedValue);
+        }
+        if (typedValue.type >= 28 && typedValue.type <= 31) {
+            return getNamedColorStateListFromInt(typedValue);
+        }
+        return ColorStateListInflaterCompat.inflate(typedArray.getResources(), typedArray.getResourceId(i, 0), theme);
+    }
+
+    private static ColorStateList getNamedColorStateListFromInt(TypedValue typedValue) {
+        return ColorStateList.valueOf(typedValue.data);
+    }
+
+    public static int getNamedResourceId(TypedArray typedArray, XmlPullParser xmlPullParser, String str, int i, int i2) {
+        return !hasAttribute(xmlPullParser, str) ? i2 : typedArray.getResourceId(i, i2);
+    }
+
+    public static String getNamedString(TypedArray typedArray, XmlPullParser xmlPullParser, String str, int i) {
+        if (hasAttribute(xmlPullParser, str)) {
+            return typedArray.getString(i);
+        }
+        return null;
+    }
+
+    public static TypedValue peekNamedValue(TypedArray typedArray, XmlPullParser xmlPullParser, String str, int i) {
+        if (hasAttribute(xmlPullParser, str)) {
+            return typedArray.peekValue(i);
+        }
+        return null;
+    }
+
+    public static TypedArray obtainAttributes(Resources resources, Resources.Theme theme, AttributeSet attributeSet, int[] iArr) {
+        if (theme == null) {
+            return resources.obtainAttributes(attributeSet, iArr);
+        }
+        return theme.obtainStyledAttributes(attributeSet, iArr, 0, 0);
+    }
+
+    public static boolean getBoolean(TypedArray typedArray, int i, int i2, boolean z) {
+        return typedArray.getBoolean(i, typedArray.getBoolean(i2, z));
+    }
+
+    public static Drawable getDrawable(TypedArray typedArray, int i, int i2) {
+        Drawable drawable = typedArray.getDrawable(i);
+        return drawable == null ? typedArray.getDrawable(i2) : drawable;
+    }
+
+    public static int getInt(TypedArray typedArray, int i, int i2, int i3) {
+        return typedArray.getInt(i, typedArray.getInt(i2, i3));
+    }
+
+    public static int getResourceId(TypedArray typedArray, int i, int i2, int i3) {
+        return typedArray.getResourceId(i, typedArray.getResourceId(i2, i3));
+    }
+
+    public static String getString(TypedArray typedArray, int i, int i2) {
+        String string = typedArray.getString(i);
+        return string == null ? typedArray.getString(i2) : string;
+    }
+
+    public static CharSequence getText(TypedArray typedArray, int i, int i2) {
+        CharSequence text = typedArray.getText(i);
+        return text == null ? typedArray.getText(i2) : text;
+    }
+
+    public static CharSequence[] getTextArray(TypedArray typedArray, int i, int i2) {
+        CharSequence[] textArray = typedArray.getTextArray(i);
+        return textArray == null ? typedArray.getTextArray(i2) : textArray;
+    }
+
+    public static int getAttr(Context context, int i, int i2) {
+        TypedValue typedValue = new TypedValue();
+        context.getTheme().resolveAttribute(i, typedValue, true);
+        return typedValue.resourceId != 0 ? i : i2;
+    }
+
+    private TypedArrayUtils() {
+    }
+}

02-Easy5/E5/sources/androidx/core/content/res/ViewingConditions.java

@@ -0,0 +1,107 @@
+package androidx.core.content.res;
+
+/* loaded from: classes.dex */
+final class ViewingConditions {
+    static final ViewingConditions DEFAULT = make(CamUtils.WHITE_POINT_D65, (float) ((CamUtils.yFromLStar(50.0f) * 63.66197723675813d) / 100.0d), 50.0f, 2.0f, false);
+    private final float mAw;
+    private final float mC;
+    private final float mFl;
+    private final float mFlRoot;
+    private final float mN;
+    private final float mNbb;
+    private final float mNc;
+    private final float mNcb;
+    private final float[] mRgbD;
+    private final float mZ;
+
+    float getAw() {
+        return this.mAw;
+    }
+
+    float getC() {
+        return this.mC;
+    }
+
+    float getFl() {
+        return this.mFl;
+    }
+
+    float getFlRoot() {
+        return this.mFlRoot;
+    }
+
+    float getN() {
+        return this.mN;
+    }
+
+    float getNbb() {
+        return this.mNbb;
+    }
+
+    float getNc() {
+        return this.mNc;
+    }
+
+    float getNcb() {
+        return this.mNcb;
+    }
+
+    float[] getRgbD() {
+        return this.mRgbD;
+    }
+
+    float getZ() {
+        return this.mZ;
+    }
+
+    private ViewingConditions(float f, float f2, float f3, float f4, float f5, float f6, float[] fArr, float f7, float f8, float f9) {
+        this.mN = f;
+        this.mAw = f2;
+        this.mNbb = f3;
+        this.mNcb = f4;
+        this.mC = f5;
+        this.mNc = f6;
+        this.mRgbD = fArr;
+        this.mFl = f7;
+        this.mFlRoot = f8;
+        this.mZ = f9;
+    }
+
+    static ViewingConditions make(float[] fArr, float f, float f2, float f3, boolean z) {
+        float[][] fArr2 = CamUtils.XYZ_TO_CAM16RGB;
+        float f4 = fArr[0];
+        float[] fArr3 = fArr2[0];
+        float f5 = fArr3[0] * f4;
+        float f6 = fArr[1];
+        float f7 = f5 + (fArr3[1] * f6);
+        float f8 = fArr[2];
+        float f9 = f7 + (fArr3[2] * f8);
+        float[] fArr4 = fArr2[1];
+        float f10 = (fArr4[0] * f4) + (fArr4[1] * f6) + (fArr4[2] * f8);
+        float[] fArr5 = fArr2[2];
+        float f11 = (f4 * fArr5[0]) + (f6 * fArr5[1]) + (f8 * fArr5[2]);
+        float f12 = (f3 / 10.0f) + 0.8f;
+        float lerp = ((double) f12) >= 0.9d ? CamUtils.lerp(0.59f, 0.69f, (f12 - 0.9f) * 10.0f) : CamUtils.lerp(0.525f, 0.59f, (f12 - 0.8f) * 10.0f);
+        float exp = z ? 1.0f : (1.0f - (((float) Math.exp(((-f) - 42.0f) / 92.0f)) * 0.2777778f)) * f12;
+        double d = exp;
+        if (d > 1.0d) {
+            exp = 1.0f;
+        } else if (d < 0.0d) {
+            exp = 0.0f;
+        }
+        float[] fArr6 = {(((100.0f / f9) * exp) + 1.0f) - exp, (((100.0f / f10) * exp) + 1.0f) - exp, (((100.0f / f11) * exp) + 1.0f) - exp};
+        float f13 = 1.0f / ((5.0f * f) + 1.0f);
+        float f14 = f13 * f13 * f13 * f13;
+        float f15 = 1.0f - f14;
+        float cbrt = (f14 * f) + (0.1f * f15 * f15 * ((float) Math.cbrt(f * 5.0d)));
+        float yFromLStar = CamUtils.yFromLStar(f2) / fArr[1];
+        double d2 = yFromLStar;
+        float sqrt = ((float) Math.sqrt(d2)) + 1.48f;
+        float pow = 0.725f / ((float) Math.pow(d2, 0.2d));
+        float pow2 = (float) Math.pow(((fArr6[2] * cbrt) * f11) / 100.0d, 0.42d);
+        float[] fArr7 = {(float) Math.pow(((fArr6[0] * cbrt) * f9) / 100.0d, 0.42d), (float) Math.pow(((fArr6[1] * cbrt) * f10) / 100.0d, 0.42d), pow2};
+        float f16 = fArr7[0];
+        float f17 = fArr7[1];
+        return new ViewingConditions(yFromLStar, ((((f16 * 400.0f) / (f16 + 27.13f)) * 2.0f) + ((f17 * 400.0f) / (f17 + 27.13f)) + (((400.0f * pow2) / (pow2 + 27.13f)) * 0.05f)) * pow, pow, pow, lerp, f12, fArr6, cbrt, (float) Math.pow(cbrt, 0.25d), sqrt);
+    }
+}