Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/androidx/core/R.java

@@ -0,0 +1,277 @@
+package androidx.core;
+
+/* loaded from: classes.dex */
+public final class R {
+
+    public static final class attr {
+        public static int alpha = 0x7f040055;
+        public static int font = 0x7f0400d8;
+        public static int fontProviderAuthority = 0x7f0400da;
+        public static int fontProviderCerts = 0x7f0400db;
+        public static int fontProviderFallbackQuery = 0x7f0400dc;
+        public static int fontProviderFetchStrategy = 0x7f0400dd;
+        public static int fontProviderFetchTimeout = 0x7f0400de;
+        public static int fontProviderPackage = 0x7f0400df;
+        public static int fontProviderQuery = 0x7f0400e0;
+        public static int fontProviderSystemFontFamily = 0x7f0400e1;
+        public static int fontStyle = 0x7f0400e2;
+        public static int fontVariationSettings = 0x7f0400e3;
+        public static int fontWeight = 0x7f0400e4;
+        public static int lStar = 0x7f0400fa;
+        public static int nestedScrollViewStyle = 0x7f040123;
+        public static int queryPatterns = 0x7f040138;
+        public static int shortcutMatchRequired = 0x7f04014d;
+        public static int ttcIndex = 0x7f04019c;
+
+        private attr() {
+        }
+    }
+
+    public static final class color {
+        public static int androidx_core_ripple_material_light = 0x7f060025;
+        public static int androidx_core_secondary_text_default_material_light = 0x7f060026;
+        public static int call_notification_answer_color = 0x7f06004e;
+        public static int call_notification_decline_color = 0x7f06004f;
+        public static int notification_action_color_filter = 0x7f0600e7;
+        public static int notification_icon_bg_color = 0x7f0600e8;
+
+        private color() {
+        }
+    }
+
+    public static final class dimen {
+        public static int compat_button_inset_horizontal_material = 0x7f070095;
+        public static int compat_button_inset_vertical_material = 0x7f070096;
+        public static int compat_button_padding_horizontal_material = 0x7f070097;
+        public static int compat_button_padding_vertical_material = 0x7f070098;
+        public static int compat_control_corner_material = 0x7f070099;
+        public static int compat_notification_large_icon_max_height = 0x7f07009a;
+        public static int compat_notification_large_icon_max_width = 0x7f07009b;
+        public static int notification_action_icon_size = 0x7f070105;
+        public static int notification_action_text_size = 0x7f070106;
+        public static int notification_big_circle_margin = 0x7f070107;
+        public static int notification_content_margin_start = 0x7f070108;
+        public static int notification_large_icon_height = 0x7f070109;
+        public static int notification_large_icon_width = 0x7f07010a;
+        public static int notification_main_column_padding_top = 0x7f07010b;
+        public static int notification_media_narrow_margin = 0x7f07010c;
+        public static int notification_right_icon_size = 0x7f07010d;
+        public static int notification_right_side_padding_top = 0x7f07010e;
+        public static int notification_small_icon_background_padding = 0x7f07010f;
+        public static int notification_small_icon_size_as_large = 0x7f070110;
+        public static int notification_subtext_size = 0x7f070111;
+        public static int notification_top_pad = 0x7f070112;
+        public static int notification_top_pad_large_text = 0x7f070113;
+
+        private dimen() {
+        }
+    }
+
+    public static final class drawable {
+        public static int ic_call_answer = 0x7f08018f;
+        public static int ic_call_answer_low = 0x7f080190;
+        public static int ic_call_answer_video = 0x7f080191;
+        public static int ic_call_answer_video_low = 0x7f080192;
+        public static int ic_call_decline = 0x7f080193;
+        public static int ic_call_decline_low = 0x7f080194;
+        public static int notification_action_background = 0x7f080241;
+        public static int notification_bg = 0x7f080242;
+        public static int notification_bg_low = 0x7f080243;
+        public static int notification_bg_low_normal = 0x7f080244;
+        public static int notification_bg_low_pressed = 0x7f080245;
+        public static int notification_bg_normal = 0x7f080246;
+        public static int notification_bg_normal_pressed = 0x7f080247;
+        public static int notification_icon_background = 0x7f080248;
+        public static int notification_oversize_large_icon_bg = 0x7f080249;
+        public static int notification_template_icon_bg = 0x7f08024a;
+        public static int notification_template_icon_low_bg = 0x7f08024b;
+        public static int notification_tile_bg = 0x7f08024c;
+        public static int notify_panel_notification_icon_bg = 0x7f08024d;
+
+        private drawable() {
+        }
+    }
+
+    public static final class id {
+        public static int accessibility_action_clickable_span = 0x7f0a0009;
+        public static int accessibility_custom_action_0 = 0x7f0a000a;
+        public static int accessibility_custom_action_1 = 0x7f0a000b;
+        public static int accessibility_custom_action_10 = 0x7f0a000c;
+        public static int accessibility_custom_action_11 = 0x7f0a000d;
+        public static int accessibility_custom_action_12 = 0x7f0a000e;
+        public static int accessibility_custom_action_13 = 0x7f0a000f;
+        public static int accessibility_custom_action_14 = 0x7f0a0010;
+        public static int accessibility_custom_action_15 = 0x7f0a0011;
+        public static int accessibility_custom_action_16 = 0x7f0a0012;
+        public static int accessibility_custom_action_17 = 0x7f0a0013;
+        public static int accessibility_custom_action_18 = 0x7f0a0014;
+        public static int accessibility_custom_action_19 = 0x7f0a0015;
+        public static int accessibility_custom_action_2 = 0x7f0a0016;
+        public static int accessibility_custom_action_20 = 0x7f0a0017;
+        public static int accessibility_custom_action_21 = 0x7f0a0018;
+        public static int accessibility_custom_action_22 = 0x7f0a0019;
+        public static int accessibility_custom_action_23 = 0x7f0a001a;
+        public static int accessibility_custom_action_24 = 0x7f0a001b;
+        public static int accessibility_custom_action_25 = 0x7f0a001c;
+        public static int accessibility_custom_action_26 = 0x7f0a001d;
+        public static int accessibility_custom_action_27 = 0x7f0a001e;
+        public static int accessibility_custom_action_28 = 0x7f0a001f;
+        public static int accessibility_custom_action_29 = 0x7f0a0020;
+        public static int accessibility_custom_action_3 = 0x7f0a0021;
+        public static int accessibility_custom_action_30 = 0x7f0a0022;
+        public static int accessibility_custom_action_31 = 0x7f0a0023;
+        public static int accessibility_custom_action_4 = 0x7f0a0024;
+        public static int accessibility_custom_action_5 = 0x7f0a0025;
+        public static int accessibility_custom_action_6 = 0x7f0a0026;
+        public static int accessibility_custom_action_7 = 0x7f0a0027;
+        public static int accessibility_custom_action_8 = 0x7f0a0028;
+        public static int accessibility_custom_action_9 = 0x7f0a0029;
+        public static int action_container = 0x7f0a0032;
+        public static int action_divider = 0x7f0a0034;
+        public static int action_image = 0x7f0a0035;
+        public static int action_text = 0x7f0a003c;
+        public static int actions = 0x7f0a003d;
+        public static int async = 0x7f0a0088;
+        public static int blocking = 0x7f0a0091;
+        public static int chronometer = 0x7f0a00a6;
+        public static int dialog_button = 0x7f0a00c1;
+        public static int edit_text_id = 0x7f0a00c6;
+        public static int forever = 0x7f0a0107;
+        public static int hide_ime_id = 0x7f0a010b;
+        public static int icon = 0x7f0a014a;
+        public static int icon_group = 0x7f0a014b;
+        public static int info = 0x7f0a0151;
+        public static int italic = 0x7f0a0156;
+        public static int line1 = 0x7f0a015d;
+        public static int line3 = 0x7f0a015e;
+        public static int normal = 0x7f0a022f;
+        public static int notification_background = 0x7f0a0230;
+        public static int notification_main_column = 0x7f0a0231;
+        public static int notification_main_column_container = 0x7f0a0232;
+        public static int right_icon = 0x7f0a0248;
+        public static int right_side = 0x7f0a0249;
+        public static int tag_accessibility_actions = 0x7f0a0270;
+        public static int tag_accessibility_clickable_spans = 0x7f0a0271;
+        public static int tag_accessibility_heading = 0x7f0a0272;
+        public static int tag_accessibility_pane_title = 0x7f0a0273;
+        public static int tag_on_apply_window_listener = 0x7f0a0274;
+        public static int tag_on_receive_content_listener = 0x7f0a0275;
+        public static int tag_on_receive_content_mime_types = 0x7f0a0276;
+        public static int tag_screen_reader_focusable = 0x7f0a0277;
+        public static int tag_state_description = 0x7f0a0278;
+        public static int tag_transition_group = 0x7f0a0279;
+        public static int tag_unhandled_key_event_manager = 0x7f0a027a;
+        public static int tag_unhandled_key_listeners = 0x7f0a027b;
+        public static int tag_window_insets_animation_callback = 0x7f0a027c;
+        public static int text = 0x7f0a027d;
+        public static int text2 = 0x7f0a027e;
+        public static int time = 0x7f0a0283;
+        public static int title = 0x7f0a0284;
+
+        private id() {
+        }
+    }
+
+    public static final class integer {
+        public static int status_bar_notification_info_maxnum = 0x7f0b0014;
+
+        private integer() {
+        }
+    }
+
+    public static final class layout {
+        public static int custom_dialog = 0x7f0d0033;
+        public static int ime_base_split_test_activity = 0x7f0d0053;
+        public static int ime_secondary_split_test_activity = 0x7f0d0054;
+        public static int notification_action = 0x7f0d009f;
+        public static int notification_action_tombstone = 0x7f0d00a0;
+        public static int notification_template_custom_big = 0x7f0d00a7;
+        public static int notification_template_icon_group = 0x7f0d00a8;
+        public static int notification_template_part_chronometer = 0x7f0d00ac;
+        public static int notification_template_part_time = 0x7f0d00ad;
+
+        private layout() {
+        }
+    }
+
+    public static final class string {
+        public static int call_notification_answer_action = 0x7f120079;
+        public static int call_notification_answer_video_action = 0x7f12007a;
+        public static int call_notification_decline_action = 0x7f12007b;
+        public static int call_notification_hang_up_action = 0x7f12007c;
+        public static int call_notification_incoming_text = 0x7f12007d;
+        public static int call_notification_ongoing_text = 0x7f12007e;
+        public static int call_notification_screening_text = 0x7f12007f;
+        public static int status_bar_notification_info_overflow = 0x7f120187;
+
+        private string() {
+        }
+    }
+
+    public static final class style {
+        public static int TextAppearance_Compat_Notification = 0x7f130147;
+        public static int TextAppearance_Compat_Notification_Info = 0x7f130148;
+        public static int TextAppearance_Compat_Notification_Line2 = 0x7f13014a;
+        public static int TextAppearance_Compat_Notification_Time = 0x7f13014d;
+        public static int TextAppearance_Compat_Notification_Title = 0x7f13014f;
+        public static int Widget_Compat_NotificationActionContainer = 0x7f1301c1;
+        public static int Widget_Compat_NotificationActionText = 0x7f1301c2;
+
+        private style() {
+        }
+    }
+
+    public static final class styleable {
+        public static int Capability_queryPatterns = 0x00000000;
+        public static int Capability_shortcutMatchRequired = 0x00000001;
+        public static int ColorStateListItem_alpha = 0x00000003;
+        public static int ColorStateListItem_android_alpha = 0x00000001;
+        public static int ColorStateListItem_android_color = 0x00000000;
+        public static int ColorStateListItem_android_lStar = 0x00000002;
+        public static int ColorStateListItem_lStar = 0x00000004;
+        public static int FontFamilyFont_android_font = 0x00000000;
+        public static int FontFamilyFont_android_fontStyle = 0x00000002;
+        public static int FontFamilyFont_android_fontVariationSettings = 0x00000004;
+        public static int FontFamilyFont_android_fontWeight = 0x00000001;
+        public static int FontFamilyFont_android_ttcIndex = 0x00000003;
+        public static int FontFamilyFont_font = 0x00000005;
+        public static int FontFamilyFont_fontStyle = 0x00000006;
+        public static int FontFamilyFont_fontVariationSettings = 0x00000007;
+        public static int FontFamilyFont_fontWeight = 0x00000008;
+        public static int FontFamilyFont_ttcIndex = 0x00000009;
+        public static int FontFamily_fontProviderAuthority = 0x00000000;
+        public static int FontFamily_fontProviderCerts = 0x00000001;
+        public static int FontFamily_fontProviderFallbackQuery = 0x00000002;
+        public static int FontFamily_fontProviderFetchStrategy = 0x00000003;
+        public static int FontFamily_fontProviderFetchTimeout = 0x00000004;
+        public static int FontFamily_fontProviderPackage = 0x00000005;
+        public static int FontFamily_fontProviderQuery = 0x00000006;
+        public static int FontFamily_fontProviderSystemFontFamily = 0x00000007;
+        public static int GradientColorItem_android_color = 0x00000000;
+        public static int GradientColorItem_android_offset = 0x00000001;
+        public static int GradientColor_android_centerColor = 0x00000007;
+        public static int GradientColor_android_centerX = 0x00000003;
+        public static int GradientColor_android_centerY = 0x00000004;
+        public static int GradientColor_android_endColor = 0x00000001;
+        public static int GradientColor_android_endX = 0x0000000a;
+        public static int GradientColor_android_endY = 0x0000000b;
+        public static int GradientColor_android_gradientRadius = 0x00000005;
+        public static int GradientColor_android_startColor = 0x00000000;
+        public static int GradientColor_android_startX = 0x00000008;
+        public static int GradientColor_android_startY = 0x00000009;
+        public static int GradientColor_android_tileMode = 0x00000006;
+        public static int GradientColor_android_type = 0x00000002;
+        public static int[] Capability = {com.ea.games.r3_row.R.attr.queryPatterns, com.ea.games.r3_row.R.attr.shortcutMatchRequired};
+        public static int[] ColorStateListItem = {android.R.attr.color, android.R.attr.alpha, android.R.attr.lStar, com.ea.games.r3_row.R.attr.alpha, com.ea.games.r3_row.R.attr.lStar};
+        public static int[] FontFamily = {com.ea.games.r3_row.R.attr.fontProviderAuthority, com.ea.games.r3_row.R.attr.fontProviderCerts, com.ea.games.r3_row.R.attr.fontProviderFallbackQuery, com.ea.games.r3_row.R.attr.fontProviderFetchStrategy, com.ea.games.r3_row.R.attr.fontProviderFetchTimeout, com.ea.games.r3_row.R.attr.fontProviderPackage, com.ea.games.r3_row.R.attr.fontProviderQuery, com.ea.games.r3_row.R.attr.fontProviderSystemFontFamily};
+        public static int[] FontFamilyFont = {android.R.attr.font, android.R.attr.fontWeight, android.R.attr.fontStyle, android.R.attr.ttcIndex, android.R.attr.fontVariationSettings, com.ea.games.r3_row.R.attr.font, com.ea.games.r3_row.R.attr.fontStyle, com.ea.games.r3_row.R.attr.fontVariationSettings, com.ea.games.r3_row.R.attr.fontWeight, com.ea.games.r3_row.R.attr.ttcIndex};
+        public static int[] GradientColor = {android.R.attr.startColor, android.R.attr.endColor, android.R.attr.type, android.R.attr.centerX, android.R.attr.centerY, android.R.attr.gradientRadius, android.R.attr.tileMode, android.R.attr.centerColor, android.R.attr.startX, android.R.attr.startY, android.R.attr.endX, android.R.attr.endY};
+        public static int[] GradientColorItem = {android.R.attr.color, android.R.attr.offset};
+
+        private styleable() {
+        }
+    }
+
+    private R() {
+    }
+}

decompiled/sources/androidx/core/accessibilityservice/AccessibilityServiceInfoCompat.java

@@ -0,0 +1,93 @@
+package androidx.core.accessibilityservice;
+
+import android.accessibilityservice.AccessibilityServiceInfo;
+import android.content.pm.PackageManager;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.ReplaceWith;
+import com.ironsource.v8;
+
+/* loaded from: classes.dex */
+public final class AccessibilityServiceInfoCompat {
+    public static final int CAPABILITY_CAN_FILTER_KEY_EVENTS = 8;
+    public static final int CAPABILITY_CAN_REQUEST_ENHANCED_WEB_ACCESSIBILITY = 4;
+    public static final int CAPABILITY_CAN_REQUEST_TOUCH_EXPLORATION = 2;
+    public static final int CAPABILITY_CAN_RETRIEVE_WINDOW_CONTENT = 1;
+    public static final int FEEDBACK_ALL_MASK = -1;
+    public static final int FEEDBACK_BRAILLE = 32;
+    public static final int FLAG_INCLUDE_NOT_IMPORTANT_VIEWS = 2;
+    public static final int FLAG_REPORT_VIEW_IDS = 16;
+    public static final int FLAG_REQUEST_ENHANCED_WEB_ACCESSIBILITY = 8;
+    public static final int FLAG_REQUEST_FILTER_KEY_EVENTS = 32;
+    public static final int FLAG_REQUEST_TOUCH_EXPLORATION_MODE = 4;
+
+    @NonNull
+    public static String capabilityToString(int i) {
+        return i != 1 ? i != 2 ? i != 4 ? i != 8 ? "UNKNOWN" : "CAPABILITY_CAN_FILTER_KEY_EVENTS" : "CAPABILITY_CAN_REQUEST_ENHANCED_WEB_ACCESSIBILITY" : "CAPABILITY_CAN_REQUEST_TOUCH_EXPLORATION" : "CAPABILITY_CAN_RETRIEVE_WINDOW_CONTENT";
+    }
+
+    @Nullable
+    public static String flagToString(int i) {
+        if (i == 1) {
+            return "DEFAULT";
+        }
+        if (i == 2) {
+            return "FLAG_INCLUDE_NOT_IMPORTANT_VIEWS";
+        }
+        if (i == 4) {
+            return "FLAG_REQUEST_TOUCH_EXPLORATION_MODE";
+        }
+        if (i == 8) {
+            return "FLAG_REQUEST_ENHANCED_WEB_ACCESSIBILITY";
+        }
+        if (i == 16) {
+            return "FLAG_REPORT_VIEW_IDS";
+        }
+        if (i != 32) {
+            return null;
+        }
+        return "FLAG_REQUEST_FILTER_KEY_EVENTS";
+    }
+
+    private AccessibilityServiceInfoCompat() {
+    }
+
+    @Nullable
+    @ReplaceWith(expression = "info.loadDescription(packageManager)")
+    @Deprecated
+    public static String loadDescription(@NonNull AccessibilityServiceInfo accessibilityServiceInfo, @NonNull PackageManager packageManager) {
+        return accessibilityServiceInfo.loadDescription(packageManager);
+    }
+
+    @NonNull
+    public static String feedbackTypeToString(int i) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(v8.i.d);
+        while (i > 0) {
+            int numberOfTrailingZeros = 1 << Integer.numberOfTrailingZeros(i);
+            i &= ~numberOfTrailingZeros;
+            if (sb.length() > 1) {
+                sb.append(", ");
+            }
+            if (numberOfTrailingZeros == 1) {
+                sb.append("FEEDBACK_SPOKEN");
+            } else if (numberOfTrailingZeros == 2) {
+                sb.append("FEEDBACK_HAPTIC");
+            } else if (numberOfTrailingZeros == 4) {
+                sb.append("FEEDBACK_AUDIBLE");
+            } else if (numberOfTrailingZeros == 8) {
+                sb.append("FEEDBACK_VISUAL");
+            } else if (numberOfTrailingZeros == 16) {
+                sb.append("FEEDBACK_GENERIC");
+            }
+        }
+        sb.append(v8.i.e);
+        return sb.toString();
+    }
+
+    @ReplaceWith(expression = "info.getCapabilities()")
+    @Deprecated
+    public static int getCapabilities(@NonNull AccessibilityServiceInfo accessibilityServiceInfo) {
+        return accessibilityServiceInfo.getCapabilities();
+    }
+}

decompiled/sources/androidx/core/animation/AnimatorKt$addListener$listener$1.java

@@ -0,0 +1,39 @@
+package androidx.core.animation;
+
+import android.animation.Animator;
+import kotlin.jvm.functions.Function1;
+
+/* loaded from: classes.dex */
+public final class AnimatorKt$addListener$listener$1 implements Animator.AnimatorListener {
+    final /* synthetic */ Function1 $onCancel;
+    final /* synthetic */ Function1 $onEnd;
+    final /* synthetic */ Function1 $onRepeat;
+    final /* synthetic */ Function1 $onStart;
+
+    public AnimatorKt$addListener$listener$1(Function1 function1, Function1 function12, Function1 function13, Function1 function14) {
+        this.$onRepeat = function1;
+        this.$onEnd = function12;
+        this.$onCancel = function13;
+        this.$onStart = function14;
+    }
+
+    @Override // android.animation.Animator.AnimatorListener
+    public void onAnimationRepeat(Animator animator) {
+        this.$onRepeat.invoke(animator);
+    }
+
+    @Override // android.animation.Animator.AnimatorListener
+    public void onAnimationEnd(Animator animator) {
+        this.$onEnd.invoke(animator);
+    }
+
+    @Override // android.animation.Animator.AnimatorListener
+    public void onAnimationCancel(Animator animator) {
+        this.$onCancel.invoke(animator);
+    }
+
+    @Override // android.animation.Animator.AnimatorListener
+    public void onAnimationStart(Animator animator) {
+        this.$onStart.invoke(animator);
+    }
+}

decompiled/sources/androidx/core/animation/AnimatorKt.java

@@ -0,0 +1,214 @@
+package androidx.core.animation;
+
+import android.animation.Animator;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nAnimator.kt\nKotlin\n*S Kotlin\n*F\n+ 1 Animator.kt\nandroidx/core/animation/AnimatorKt\n*L\n1#1,123:1\n85#1,18:124\n85#1,18:142\n85#1,18:160\n85#1,18:178\n*S KotlinDebug\n*F\n+ 1 Animator.kt\nandroidx/core/animation/AnimatorKt\n*L\n29#1:124,18\n39#1:142,18\n49#1:160,18\n58#1:178,18\n*E\n"})
+/* loaded from: classes.dex */
+public final class AnimatorKt {
+    public static final Animator.AnimatorPauseListener doOnResume(Animator animator, Function1 function1) {
+        return addPauseListener$default(animator, function1, null, 2, null);
+    }
+
+    public static final Animator.AnimatorPauseListener doOnPause(Animator animator, Function1 function1) {
+        return addPauseListener$default(animator, null, function1, 1, null);
+    }
+
+    public static final Animator.AnimatorListener addListener(Animator animator, Function1 function1, Function1 function12, Function1 function13, Function1 function14) {
+        AnimatorKt$addListener$listener$1 animatorKt$addListener$listener$1 = new AnimatorKt$addListener$listener$1(function14, function1, function13, function12);
+        animator.addListener(animatorKt$addListener$listener$1);
+        return animatorKt$addListener$listener$1;
+    }
+
+    public static /* synthetic */ Animator.AnimatorListener addListener$default(Animator animator, Function1 function1, Function1 function12, Function1 function13, Function1 function14, int i, Object obj) {
+        if ((i & 1) != 0) {
+            function1 = new Function1() { // from class: androidx.core.animation.AnimatorKt$addListener$1
+                public final void invoke(Animator animator2) {
+                }
+
+                @Override // kotlin.jvm.functions.Function1
+                public /* bridge */ /* synthetic */ Object invoke(Object obj2) {
+                    invoke((Animator) obj2);
+                    return Unit.INSTANCE;
+                }
+            };
+        }
+        if ((i & 2) != 0) {
+            function12 = new Function1() { // from class: androidx.core.animation.AnimatorKt$addListener$2
+                public final void invoke(Animator animator2) {
+                }
+
+                @Override // kotlin.jvm.functions.Function1
+                public /* bridge */ /* synthetic */ Object invoke(Object obj2) {
+                    invoke((Animator) obj2);
+                    return Unit.INSTANCE;
+                }
+            };
+        }
+        if ((i & 4) != 0) {
+            function13 = new Function1() { // from class: androidx.core.animation.AnimatorKt$addListener$3
+                public final void invoke(Animator animator2) {
+                }
+
+                @Override // kotlin.jvm.functions.Function1
+                public /* bridge */ /* synthetic */ Object invoke(Object obj2) {
+                    invoke((Animator) obj2);
+                    return Unit.INSTANCE;
+                }
+            };
+        }
+        if ((i & 8) != 0) {
+            function14 = new Function1() { // from class: androidx.core.animation.AnimatorKt$addListener$4
+                public final void invoke(Animator animator2) {
+                }
+
+                @Override // kotlin.jvm.functions.Function1
+                public /* bridge */ /* synthetic */ Object invoke(Object obj2) {
+                    invoke((Animator) obj2);
+                    return Unit.INSTANCE;
+                }
+            };
+        }
+        AnimatorKt$addListener$listener$1 animatorKt$addListener$listener$1 = new AnimatorKt$addListener$listener$1(function14, function1, function13, function12);
+        animator.addListener(animatorKt$addListener$listener$1);
+        return animatorKt$addListener$listener$1;
+    }
+
+    public static final Animator.AnimatorListener doOnCancel(Animator animator, final Function1 function1) {
+        Animator.AnimatorListener animatorListener = new Animator.AnimatorListener() { // from class: androidx.core.animation.AnimatorKt$doOnCancel$$inlined$addListener$default$1
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationEnd(Animator animator2) {
+            }
+
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationRepeat(Animator animator2) {
+            }
+
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationStart(Animator animator2) {
+            }
+
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationCancel(Animator animator2) {
+                Function1.this.invoke(animator2);
+            }
+        };
+        animator.addListener(animatorListener);
+        return animatorListener;
+    }
+
+    public static final Animator.AnimatorListener doOnEnd(Animator animator, final Function1 function1) {
+        Animator.AnimatorListener animatorListener = new Animator.AnimatorListener() { // from class: androidx.core.animation.AnimatorKt$doOnEnd$$inlined$addListener$default$1
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationCancel(Animator animator2) {
+            }
+
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationRepeat(Animator animator2) {
+            }
+
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationStart(Animator animator2) {
+            }
+
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationEnd(Animator animator2) {
+                Function1.this.invoke(animator2);
+            }
+        };
+        animator.addListener(animatorListener);
+        return animatorListener;
+    }
+
+    public static final Animator.AnimatorListener doOnRepeat(Animator animator, final Function1 function1) {
+        Animator.AnimatorListener animatorListener = new Animator.AnimatorListener() { // from class: androidx.core.animation.AnimatorKt$doOnRepeat$$inlined$addListener$default$1
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationCancel(Animator animator2) {
+            }
+
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationEnd(Animator animator2) {
+            }
+
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationStart(Animator animator2) {
+            }
+
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationRepeat(Animator animator2) {
+                Function1.this.invoke(animator2);
+            }
+        };
+        animator.addListener(animatorListener);
+        return animatorListener;
+    }
+
+    public static final Animator.AnimatorListener doOnStart(Animator animator, final Function1 function1) {
+        Animator.AnimatorListener animatorListener = new Animator.AnimatorListener() { // from class: androidx.core.animation.AnimatorKt$doOnStart$$inlined$addListener$default$1
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationCancel(Animator animator2) {
+            }
+
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationEnd(Animator animator2) {
+            }
+
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationRepeat(Animator animator2) {
+            }
+
+            @Override // android.animation.Animator.AnimatorListener
+            public void onAnimationStart(Animator animator2) {
+                Function1.this.invoke(animator2);
+            }
+        };
+        animator.addListener(animatorListener);
+        return animatorListener;
+    }
+
+    public static /* synthetic */ Animator.AnimatorPauseListener addPauseListener$default(Animator animator, Function1 function1, Function1 function12, int i, Object obj) {
+        if ((i & 1) != 0) {
+            function1 = new Function1() { // from class: androidx.core.animation.AnimatorKt$addPauseListener$1
+                public final void invoke(Animator animator2) {
+                }
+
+                @Override // kotlin.jvm.functions.Function1
+                public /* bridge */ /* synthetic */ Object invoke(Object obj2) {
+                    invoke((Animator) obj2);
+                    return Unit.INSTANCE;
+                }
+            };
+        }
+        if ((i & 2) != 0) {
+            function12 = new Function1() { // from class: androidx.core.animation.AnimatorKt$addPauseListener$2
+                public final void invoke(Animator animator2) {
+                }
+
+                @Override // kotlin.jvm.functions.Function1
+                public /* bridge */ /* synthetic */ Object invoke(Object obj2) {
+                    invoke((Animator) obj2);
+                    return Unit.INSTANCE;
+                }
+            };
+        }
+        return addPauseListener(animator, function1, function12);
+    }
+
+    public static final Animator.AnimatorPauseListener addPauseListener(Animator animator, final Function1 function1, final Function1 function12) {
+        Animator.AnimatorPauseListener animatorPauseListener = new Animator.AnimatorPauseListener() { // from class: androidx.core.animation.AnimatorKt$addPauseListener$listener$1
+            @Override // android.animation.Animator.AnimatorPauseListener
+            public void onAnimationPause(Animator animator2) {
+                Function1.this.invoke(animator2);
+            }
+
+            @Override // android.animation.Animator.AnimatorPauseListener
+            public void onAnimationResume(Animator animator2) {
+                function1.invoke(animator2);
+            }
+        };
+        animator.addPauseListener(animatorPauseListener);
+        return animatorPauseListener;
+    }
+}

decompiled/sources/androidx/core/app/ActivityCompat.java

@@ -0,0 +1,398 @@
+package androidx.core.app;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.app.SharedElementCallback;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.content.Intent;
+import android.content.IntentSender;
+import android.content.pm.PackageManager;
+import android.graphics.Matrix;
+import android.graphics.RectF;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Parcelable;
+import android.text.TextUtils;
+import android.view.Display;
+import android.view.DragEvent;
+import android.view.View;
+import androidx.annotation.IdRes;
+import androidx.annotation.IntRange;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.core.app.ActivityCompat;
+import androidx.core.app.SharedElementCallback;
+import androidx.core.content.ContextCompat;
+import androidx.core.content.LocusIdCompat;
+import androidx.core.view.DragAndDropPermissionsCompat;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class ActivityCompat extends ContextCompat {
+    private static PermissionCompatDelegate sDelegate;
+
+    public interface OnRequestPermissionsResultCallback {
+        void onRequestPermissionsResult(int i, @NonNull String[] strArr, @NonNull int[] iArr);
+    }
+
+    public interface PermissionCompatDelegate {
+        boolean onActivityResult(@NonNull Activity activity, @IntRange(from = 0) int i, int i2, @Nullable Intent intent);
+
+        boolean requestPermissions(@NonNull Activity activity, @NonNull String[] strArr, @IntRange(from = 0) int i);
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public interface RequestPermissionsRequestCodeValidator {
+        void validateRequestPermissionsRequestCode(int i);
+    }
+
+    @Nullable
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static PermissionCompatDelegate getPermissionCompatDelegate() {
+        return sDelegate;
+    }
+
+    public static void setPermissionCompatDelegate(@Nullable PermissionCompatDelegate permissionCompatDelegate) {
+        sDelegate = permissionCompatDelegate;
+    }
+
+    @Deprecated
+    public static boolean invalidateOptionsMenu(Activity activity) {
+        activity.invalidateOptionsMenu();
+        return true;
+    }
+
+    public static void startActivityForResult(@NonNull Activity activity, @NonNull Intent intent, int i, @Nullable Bundle bundle) {
+        activity.startActivityForResult(intent, i, bundle);
+    }
+
+    public static void startIntentSenderForResult(@NonNull Activity activity, @NonNull IntentSender intentSender, int i, @Nullable Intent intent, int i2, int i3, int i4, @Nullable Bundle bundle) throws IntentSender.SendIntentException {
+        activity.startIntentSenderForResult(intentSender, i, intent, i2, i3, i4, bundle);
+    }
+
+    public static void finishAffinity(@NonNull Activity activity) {
+        activity.finishAffinity();
+    }
+
+    public static void finishAfterTransition(@NonNull Activity activity) {
+        Api21Impl.finishAfterTransition(activity);
+    }
+
+    @Nullable
+    public static Uri getReferrer(@NonNull Activity activity) {
+        return Api22Impl.getReferrer(activity);
+    }
+
+    @NonNull
+    public static <T extends View> T requireViewById(@NonNull Activity activity, @IdRes int i) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return (T) Api28Impl.requireViewById(activity, i);
+        }
+        T t = (T) activity.findViewById(i);
+        if (t != null) {
+            return t;
+        }
+        throw new IllegalArgumentException("ID does not reference a View inside this Activity");
+    }
+
+    public static void setEnterSharedElementCallback(@NonNull Activity activity, @Nullable SharedElementCallback sharedElementCallback) {
+        Api21Impl.setEnterSharedElementCallback(activity, sharedElementCallback != null ? new SharedElementCallback21Impl(sharedElementCallback) : null);
+    }
+
+    public static void setExitSharedElementCallback(@NonNull Activity activity, @Nullable SharedElementCallback sharedElementCallback) {
+        Api21Impl.setExitSharedElementCallback(activity, sharedElementCallback != null ? new SharedElementCallback21Impl(sharedElementCallback) : null);
+    }
+
+    public static void postponeEnterTransition(@NonNull Activity activity) {
+        Api21Impl.postponeEnterTransition(activity);
+    }
+
+    public static void startPostponedEnterTransition(@NonNull Activity activity) {
+        Api21Impl.startPostponedEnterTransition(activity);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public static void requestPermissions(@NonNull Activity activity, @NonNull String[] strArr, @IntRange(from = 0) int i) {
+        PermissionCompatDelegate permissionCompatDelegate = sDelegate;
+        if (permissionCompatDelegate == null || !permissionCompatDelegate.requestPermissions(activity, strArr, i)) {
+            HashSet hashSet = new HashSet();
+            for (int i2 = 0; i2 < strArr.length; i2++) {
+                if (TextUtils.isEmpty(strArr[i2])) {
+                    throw new IllegalArgumentException("Permission request for permissions " + Arrays.toString(strArr) + " must not contain null or empty values");
+                }
+                if (Build.VERSION.SDK_INT < 33 && TextUtils.equals(strArr[i2], "android.permission.POST_NOTIFICATIONS")) {
+                    hashSet.add(Integer.valueOf(i2));
+                }
+            }
+            int size = hashSet.size();
+            String[] strArr2 = size > 0 ? new String[strArr.length - size] : strArr;
+            if (size > 0) {
+                if (size == strArr.length) {
+                    return;
+                }
+                int i3 = 0;
+                for (int i4 = 0; i4 < strArr.length; i4++) {
+                    if (!hashSet.contains(Integer.valueOf(i4))) {
+                        strArr2[i3] = strArr[i4];
+                        i3++;
+                    }
+                }
+            }
+            if (activity instanceof RequestPermissionsRequestCodeValidator) {
+                ((RequestPermissionsRequestCodeValidator) activity).validateRequestPermissionsRequestCode(i);
+            }
+            Api23Impl.requestPermissions(activity, strArr, i);
+        }
+    }
+
+    /* renamed from: androidx.core.app.ActivityCompat$1, reason: invalid class name */
+    public class AnonymousClass1 implements Runnable {
+        final /* synthetic */ Activity val$activity;
+        final /* synthetic */ String[] val$permissionsArray;
+        final /* synthetic */ int val$requestCode;
+
+        public AnonymousClass1(String[] strArr, Activity activity, int i) {
+            this.val$permissionsArray = strArr;
+            this.val$activity = activity;
+            this.val$requestCode = i;
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            int[] iArr = new int[this.val$permissionsArray.length];
+            PackageManager packageManager = this.val$activity.getPackageManager();
+            String packageName = this.val$activity.getPackageName();
+            int length = this.val$permissionsArray.length;
+            for (int i = 0; i < length; i++) {
+                iArr[i] = packageManager.checkPermission(this.val$permissionsArray[i], packageName);
+            }
+            ((OnRequestPermissionsResultCallback) this.val$activity).onRequestPermissionsResult(this.val$requestCode, this.val$permissionsArray, iArr);
+        }
+    }
+
+    public static boolean shouldShowRequestPermissionRationale(@NonNull Activity activity, @NonNull String str) {
+        int i = Build.VERSION.SDK_INT;
+        if (i < 33 && TextUtils.equals("android.permission.POST_NOTIFICATIONS", str)) {
+            return false;
+        }
+        if (i >= 32) {
+            return Api32Impl.shouldShowRequestPermissionRationale(activity, str);
+        }
+        if (i == 31) {
+            return Api31Impl.shouldShowRequestPermissionRationale(activity, str);
+        }
+        return Api23Impl.shouldShowRequestPermissionRationale(activity, str);
+    }
+
+    public static boolean isLaunchedFromBubble(@NonNull Activity activity) {
+        int i = Build.VERSION.SDK_INT;
+        if (i >= 31) {
+            return Api31Impl.isLaunchedFromBubble(activity);
+        }
+        if (i == 30) {
+            return (Api30Impl.getDisplay(activity) == null || Api30Impl.getDisplay(activity).getDisplayId() == 0) ? false : true;
+        }
+        if (i == 29) {
+            return (activity.getWindowManager().getDefaultDisplay() == null || activity.getWindowManager().getDefaultDisplay().getDisplayId() == 0) ? false : true;
+        }
+        return false;
+    }
+
+    @Nullable
+    public static DragAndDropPermissionsCompat requestDragAndDropPermissions(@NonNull Activity activity, @NonNull DragEvent dragEvent) {
+        return DragAndDropPermissionsCompat.request(activity, dragEvent);
+    }
+
+    public static void recreate(@NonNull final Activity activity) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            activity.recreate();
+        } else {
+            new Handler(activity.getMainLooper()).post(new Runnable() { // from class: androidx.core.app.ActivityCompat$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    ActivityCompat.lambda$recreate$0(activity);
+                }
+            });
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static /* synthetic */ void lambda$recreate$0(Activity activity) {
+        if (activity.isFinishing() || ActivityRecreator.recreate(activity)) {
+            return;
+        }
+        activity.recreate();
+    }
+
+    public static void setLocusContext(@NonNull Activity activity, @Nullable LocusIdCompat locusIdCompat, @Nullable Bundle bundle) {
+        if (Build.VERSION.SDK_INT >= 30) {
+            Api30Impl.setLocusContext(activity, locusIdCompat, bundle);
+        }
+    }
+
+    @RequiresApi(21)
+    public static class SharedElementCallback21Impl extends android.app.SharedElementCallback {
+        private final SharedElementCallback mCallback;
+
+        public SharedElementCallback21Impl(SharedElementCallback sharedElementCallback) {
+            this.mCallback = sharedElementCallback;
+        }
+
+        @Override // android.app.SharedElementCallback
+        public void onSharedElementStart(List<String> list, List<View> list2, List<View> list3) {
+            this.mCallback.onSharedElementStart(list, list2, list3);
+        }
+
+        @Override // android.app.SharedElementCallback
+        public void onSharedElementEnd(List<String> list, List<View> list2, List<View> list3) {
+            this.mCallback.onSharedElementEnd(list, list2, list3);
+        }
+
+        @Override // android.app.SharedElementCallback
+        public void onRejectSharedElements(List<View> list) {
+            this.mCallback.onRejectSharedElements(list);
+        }
+
+        @Override // android.app.SharedElementCallback
+        public void onMapSharedElements(List<String> list, Map<String, View> map) {
+            this.mCallback.onMapSharedElements(list, map);
+        }
+
+        @Override // android.app.SharedElementCallback
+        public Parcelable onCaptureSharedElementSnapshot(View view, Matrix matrix, RectF rectF) {
+            return this.mCallback.onCaptureSharedElementSnapshot(view, matrix, rectF);
+        }
+
+        @Override // android.app.SharedElementCallback
+        public View onCreateSnapshotView(Context context, Parcelable parcelable) {
+            return this.mCallback.onCreateSnapshotView(context, parcelable);
+        }
+
+        @Override // android.app.SharedElementCallback
+        @RequiresApi(23)
+        public void onSharedElementsArrived(List<String> list, List<View> list2, final SharedElementCallback.OnSharedElementsReadyListener onSharedElementsReadyListener) {
+            this.mCallback.onSharedElementsArrived(list, list2, new SharedElementCallback.OnSharedElementsReadyListener() { // from class: androidx.core.app.ActivityCompat$SharedElementCallback21Impl$$ExternalSyntheticLambda0
+                @Override // androidx.core.app.SharedElementCallback.OnSharedElementsReadyListener
+                public final void onSharedElementsReady() {
+                    ActivityCompat.Api23Impl.onSharedElementsReady(onSharedElementsReadyListener);
+                }
+            });
+        }
+    }
+
+    @RequiresApi(30)
+    public static class Api30Impl {
+        private Api30Impl() {
+        }
+
+        public static void setLocusContext(@NonNull Activity activity, @Nullable LocusIdCompat locusIdCompat, @Nullable Bundle bundle) {
+            activity.setLocusContext(locusIdCompat == null ? null : locusIdCompat.toLocusId(), bundle);
+        }
+
+        public static Display getDisplay(ContextWrapper contextWrapper) {
+            return contextWrapper.getDisplay();
+        }
+    }
+
+    @RequiresApi(31)
+    public static class Api31Impl {
+        private Api31Impl() {
+        }
+
+        public static boolean isLaunchedFromBubble(@NonNull Activity activity) {
+            return activity.isLaunchedFromBubble();
+        }
+
+        @SuppressLint({"BanUncheckedReflection"})
+        public static boolean shouldShowRequestPermissionRationale(Activity activity, String str) {
+            try {
+                return ((Boolean) PackageManager.class.getMethod("shouldShowRequestPermissionRationale", String.class).invoke(activity.getApplication().getPackageManager(), str)).booleanValue();
+            } catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException unused) {
+                return activity.shouldShowRequestPermissionRationale(str);
+            }
+        }
+    }
+
+    @RequiresApi(32)
+    public static class Api32Impl {
+        private Api32Impl() {
+        }
+
+        public static boolean shouldShowRequestPermissionRationale(Activity activity, String str) {
+            return activity.shouldShowRequestPermissionRationale(str);
+        }
+    }
+
+    @RequiresApi(21)
+    public static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        public static void finishAfterTransition(Activity activity) {
+            activity.finishAfterTransition();
+        }
+
+        public static void setEnterSharedElementCallback(Activity activity, android.app.SharedElementCallback sharedElementCallback) {
+            activity.setEnterSharedElementCallback(sharedElementCallback);
+        }
+
+        public static void setExitSharedElementCallback(Activity activity, android.app.SharedElementCallback sharedElementCallback) {
+            activity.setExitSharedElementCallback(sharedElementCallback);
+        }
+
+        public static void postponeEnterTransition(Activity activity) {
+            activity.postponeEnterTransition();
+        }
+
+        public static void startPostponedEnterTransition(Activity activity) {
+            activity.startPostponedEnterTransition();
+        }
+    }
+
+    @RequiresApi(22)
+    public static class Api22Impl {
+        private Api22Impl() {
+        }
+
+        public static Uri getReferrer(Activity activity) {
+            return activity.getReferrer();
+        }
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static <T> T requireViewById(Activity activity, int i) {
+            return (T) activity.requireViewById(i);
+        }
+    }
+
+    @RequiresApi(23)
+    public static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        public static void requestPermissions(Activity activity, String[] strArr, int i) {
+            activity.requestPermissions(strArr, i);
+        }
+
+        public static boolean shouldShowRequestPermissionRationale(Activity activity, String str) {
+            return activity.shouldShowRequestPermissionRationale(str);
+        }
+
+        public static void onSharedElementsReady(Object obj) {
+            ((SharedElementCallback.OnSharedElementsReadyListener) obj).onSharedElementsReady();
+        }
+    }
+}

decompiled/sources/androidx/core/app/ActivityManagerCompat.java

@@ -0,0 +1,17 @@
+package androidx.core.app;
+
+import android.app.ActivityManager;
+import androidx.annotation.NonNull;
+import androidx.annotation.ReplaceWith;
+
+/* loaded from: classes.dex */
+public final class ActivityManagerCompat {
+    private ActivityManagerCompat() {
+    }
+
+    @ReplaceWith(expression = "activityManager.isLowRamDevice()")
+    @Deprecated
+    public static boolean isLowRamDevice(@NonNull ActivityManager activityManager) {
+        return activityManager.isLowRamDevice();
+    }
+}

decompiled/sources/androidx/core/app/ActivityOptionsCompat.java

@@ -0,0 +1,239 @@
+package androidx.core.app;
+
+import android.app.Activity;
+import android.app.ActivityOptions;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.os.Build;
+import android.os.Bundle;
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.core.util.Pair;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes.dex */
+public class ActivityOptionsCompat {
+    public static final String EXTRA_USAGE_TIME_REPORT = "android.activity.usage_time";
+    public static final String EXTRA_USAGE_TIME_REPORT_PACKAGES = "android.usage_time_packages";
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public @interface BackgroundActivityStartMode {
+    }
+
+    @Nullable
+    public Rect getLaunchBounds() {
+        return null;
+    }
+
+    public void requestUsageTimeReport(@NonNull PendingIntent pendingIntent) {
+    }
+
+    @NonNull
+    public ActivityOptionsCompat setLaunchBounds(@Nullable Rect rect) {
+        return this;
+    }
+
+    @NonNull
+    public ActivityOptionsCompat setPendingIntentBackgroundActivityStartMode(int i) {
+        return this;
+    }
+
+    @NonNull
+    public ActivityOptionsCompat setShareIdentityEnabled(boolean z) {
+        return this;
+    }
+
+    @Nullable
+    public Bundle toBundle() {
+        return null;
+    }
+
+    public void update(@NonNull ActivityOptionsCompat activityOptionsCompat) {
+    }
+
+    @NonNull
+    public static ActivityOptionsCompat makeCustomAnimation(@NonNull Context context, int i, int i2) {
+        return new ActivityOptionsCompatImpl(ActivityOptions.makeCustomAnimation(context, i, i2));
+    }
+
+    @NonNull
+    public static ActivityOptionsCompat makeScaleUpAnimation(@NonNull View view, int i, int i2, int i3, int i4) {
+        return new ActivityOptionsCompatImpl(ActivityOptions.makeScaleUpAnimation(view, i, i2, i3, i4));
+    }
+
+    @NonNull
+    public static ActivityOptionsCompat makeClipRevealAnimation(@NonNull View view, int i, int i2, int i3, int i4) {
+        return new ActivityOptionsCompatImpl(Api23Impl.makeClipRevealAnimation(view, i, i2, i3, i4));
+    }
+
+    @NonNull
+    public static ActivityOptionsCompat makeThumbnailScaleUpAnimation(@NonNull View view, @NonNull Bitmap bitmap, int i, int i2) {
+        return new ActivityOptionsCompatImpl(ActivityOptions.makeThumbnailScaleUpAnimation(view, bitmap, i, i2));
+    }
+
+    @NonNull
+    public static ActivityOptionsCompat makeSceneTransitionAnimation(@NonNull Activity activity, @NonNull View view, @NonNull String str) {
+        return new ActivityOptionsCompatImpl(Api21Impl.makeSceneTransitionAnimation(activity, view, str));
+    }
+
+    @NonNull
+    public static ActivityOptionsCompat makeSceneTransitionAnimation(@NonNull Activity activity, @Nullable Pair<View, String>... pairArr) {
+        android.util.Pair[] pairArr2;
+        if (pairArr != null) {
+            pairArr2 = new android.util.Pair[pairArr.length];
+            for (int i = 0; i < pairArr.length; i++) {
+                Pair<View, String> pair = pairArr[i];
+                pairArr2[i] = android.util.Pair.create(pair.first, pair.second);
+            }
+        } else {
+            pairArr2 = null;
+        }
+        return new ActivityOptionsCompatImpl(Api21Impl.makeSceneTransitionAnimation(activity, pairArr2));
+    }
+
+    @NonNull
+    public static ActivityOptionsCompat makeTaskLaunchBehind() {
+        return new ActivityOptionsCompatImpl(Api21Impl.makeTaskLaunchBehind());
+    }
+
+    @NonNull
+    public static ActivityOptionsCompat makeBasic() {
+        return new ActivityOptionsCompatImpl(Api23Impl.makeBasic());
+    }
+
+    public static class ActivityOptionsCompatImpl extends ActivityOptionsCompat {
+        private final ActivityOptions mActivityOptions;
+
+        public ActivityOptionsCompatImpl(ActivityOptions activityOptions) {
+            this.mActivityOptions = activityOptions;
+        }
+
+        @Override // androidx.core.app.ActivityOptionsCompat
+        public Bundle toBundle() {
+            return this.mActivityOptions.toBundle();
+        }
+
+        @Override // androidx.core.app.ActivityOptionsCompat
+        public void update(@NonNull ActivityOptionsCompat activityOptionsCompat) {
+            if (activityOptionsCompat instanceof ActivityOptionsCompatImpl) {
+                this.mActivityOptions.update(((ActivityOptionsCompatImpl) activityOptionsCompat).mActivityOptions);
+            }
+        }
+
+        @Override // androidx.core.app.ActivityOptionsCompat
+        public void requestUsageTimeReport(@NonNull PendingIntent pendingIntent) {
+            Api23Impl.requestUsageTimeReport(this.mActivityOptions, pendingIntent);
+        }
+
+        @Override // androidx.core.app.ActivityOptionsCompat
+        @NonNull
+        public ActivityOptionsCompat setLaunchBounds(@Nullable Rect rect) {
+            return new ActivityOptionsCompatImpl(Api24Impl.setLaunchBounds(this.mActivityOptions, rect));
+        }
+
+        @Override // androidx.core.app.ActivityOptionsCompat
+        public Rect getLaunchBounds() {
+            return Api24Impl.getLaunchBounds(this.mActivityOptions);
+        }
+
+        @Override // androidx.core.app.ActivityOptionsCompat
+        @NonNull
+        public ActivityOptionsCompat setShareIdentityEnabled(boolean z) {
+            return Build.VERSION.SDK_INT < 34 ? this : new ActivityOptionsCompatImpl(Api34Impl.setShareIdentityEnabled(this.mActivityOptions, z));
+        }
+
+        @Override // androidx.core.app.ActivityOptionsCompat
+        @NonNull
+        public ActivityOptionsCompat setPendingIntentBackgroundActivityStartMode(int i) {
+            int i2 = Build.VERSION.SDK_INT;
+            if (i2 >= 34) {
+                Api34Impl.setPendingIntentBackgroundActivityStartMode(this.mActivityOptions, i);
+            } else if (i2 >= 33) {
+                Api33Impl.setPendingIntentBackgroundActivityLaunchAllowed(this.mActivityOptions, i != 2);
+            }
+            return this;
+        }
+    }
+
+    @RequiresApi(23)
+    public static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        public static ActivityOptions makeClipRevealAnimation(View view, int i, int i2, int i3, int i4) {
+            return ActivityOptions.makeClipRevealAnimation(view, i, i2, i3, i4);
+        }
+
+        public static ActivityOptions makeBasic() {
+            return ActivityOptions.makeBasic();
+        }
+
+        public static void requestUsageTimeReport(ActivityOptions activityOptions, PendingIntent pendingIntent) {
+            activityOptions.requestUsageTimeReport(pendingIntent);
+        }
+    }
+
+    @RequiresApi(21)
+    public static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        public static ActivityOptions makeSceneTransitionAnimation(Activity activity, View view, String str) {
+            return ActivityOptions.makeSceneTransitionAnimation(activity, view, str);
+        }
+
+        @SafeVarargs
+        public static ActivityOptions makeSceneTransitionAnimation(Activity activity, android.util.Pair<View, String>... pairArr) {
+            return ActivityOptions.makeSceneTransitionAnimation(activity, pairArr);
+        }
+
+        public static ActivityOptions makeTaskLaunchBehind() {
+            return ActivityOptions.makeTaskLaunchBehind();
+        }
+    }
+
+    @RequiresApi(24)
+    public static class Api24Impl {
+        private Api24Impl() {
+        }
+
+        public static ActivityOptions setLaunchBounds(ActivityOptions activityOptions, Rect rect) {
+            return activityOptions.setLaunchBounds(rect);
+        }
+
+        public static Rect getLaunchBounds(ActivityOptions activityOptions) {
+            return activityOptions.getLaunchBounds();
+        }
+    }
+
+    @RequiresApi(33)
+    public static class Api33Impl {
+        private Api33Impl() {
+        }
+
+        public static void setPendingIntentBackgroundActivityLaunchAllowed(ActivityOptions activityOptions, boolean z) {
+            activityOptions.setPendingIntentBackgroundActivityLaunchAllowed(z);
+        }
+    }
+
+    @RequiresApi(34)
+    public static class Api34Impl {
+        private Api34Impl() {
+        }
+
+        public static ActivityOptions setShareIdentityEnabled(ActivityOptions activityOptions, boolean z) {
+            return activityOptions.setShareIdentityEnabled(z);
+        }
+
+        public static ActivityOptions setPendingIntentBackgroundActivityStartMode(ActivityOptions activityOptions, int i) {
+            return activityOptions.setPendingIntentBackgroundActivityStartMode(i);
+        }
+    }
+}

decompiled/sources/androidx/core/app/ActivityRecreator.java

@@ -0,0 +1,257 @@
+package androidx.core.app;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.res.Configuration;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Looper;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.List;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+final class ActivityRecreator {
+    private static final String LOG_TAG = "ActivityRecreator";
+    protected static final Class<?> activityThreadClass;
+    private static final Handler mainHandler = new Handler(Looper.getMainLooper());
+    protected static final Field mainThreadField;
+    protected static final Method performStopActivity2ParamsMethod;
+    protected static final Method performStopActivity3ParamsMethod;
+    protected static final Method requestRelaunchActivityMethod;
+    protected static final Field tokenField;
+
+    private static boolean needsRelaunchCall() {
+        int i = Build.VERSION.SDK_INT;
+        return i == 26 || i == 27;
+    }
+
+    private ActivityRecreator() {
+    }
+
+    static {
+        Class<?> activityThreadClass2 = getActivityThreadClass();
+        activityThreadClass = activityThreadClass2;
+        mainThreadField = getMainThreadField();
+        tokenField = getTokenField();
+        performStopActivity3ParamsMethod = getPerformStopActivity3Params(activityThreadClass2);
+        performStopActivity2ParamsMethod = getPerformStopActivity2Params(activityThreadClass2);
+        requestRelaunchActivityMethod = getRequestRelaunchActivityMethod(activityThreadClass2);
+    }
+
+    public static boolean recreate(@NonNull Activity activity) {
+        Object obj;
+        if (Build.VERSION.SDK_INT >= 28) {
+            activity.recreate();
+            return true;
+        }
+        if (needsRelaunchCall() && requestRelaunchActivityMethod == null) {
+            return false;
+        }
+        if (performStopActivity2ParamsMethod == null && performStopActivity3ParamsMethod == null) {
+            return false;
+        }
+        try {
+            final Object obj2 = tokenField.get(activity);
+            if (obj2 == null || (obj = mainThreadField.get(activity)) == null) {
+                return false;
+            }
+            final Application application = activity.getApplication();
+            final LifecycleCheckCallbacks lifecycleCheckCallbacks = new LifecycleCheckCallbacks(activity);
+            application.registerActivityLifecycleCallbacks(lifecycleCheckCallbacks);
+            Handler handler = mainHandler;
+            handler.post(new Runnable() { // from class: androidx.core.app.ActivityRecreator.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    LifecycleCheckCallbacks.this.currentlyRecreatingToken = obj2;
+                }
+            });
+            try {
+                if (needsRelaunchCall()) {
+                    Method method = requestRelaunchActivityMethod;
+                    Boolean bool = Boolean.FALSE;
+                    method.invoke(obj, obj2, null, null, 0, bool, null, null, bool, bool);
+                } else {
+                    activity.recreate();
+                }
+                handler.post(new Runnable() { // from class: androidx.core.app.ActivityRecreator.2
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        application.unregisterActivityLifecycleCallbacks(lifecycleCheckCallbacks);
+                    }
+                });
+                return true;
+            } catch (Throwable th) {
+                mainHandler.post(new Runnable() { // from class: androidx.core.app.ActivityRecreator.2
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        application.unregisterActivityLifecycleCallbacks(lifecycleCheckCallbacks);
+                    }
+                });
+                throw th;
+            }
+        } catch (Throwable unused) {
+            return false;
+        }
+    }
+
+    public static final class LifecycleCheckCallbacks implements Application.ActivityLifecycleCallbacks {
+        Object currentlyRecreatingToken;
+        private Activity mActivity;
+        private final int mRecreatingHashCode;
+        private boolean mStarted = false;
+        private boolean mDestroyed = false;
+        private boolean mStopQueued = false;
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityCreated(Activity activity, Bundle bundle) {
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityDestroyed(Activity activity) {
+            if (this.mActivity == activity) {
+                this.mActivity = null;
+                this.mDestroyed = true;
+            }
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityResumed(Activity activity) {
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityStarted(Activity activity) {
+            if (this.mActivity == activity) {
+                this.mStarted = true;
+            }
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityStopped(Activity activity) {
+        }
+
+        public LifecycleCheckCallbacks(@NonNull Activity activity) {
+            this.mActivity = activity;
+            this.mRecreatingHashCode = activity.hashCode();
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityPaused(Activity activity) {
+            if (!this.mDestroyed || this.mStopQueued || this.mStarted || !ActivityRecreator.queueOnStopIfNecessary(this.currentlyRecreatingToken, this.mRecreatingHashCode, activity)) {
+                return;
+            }
+            this.mStopQueued = true;
+            this.currentlyRecreatingToken = null;
+        }
+    }
+
+    public static boolean queueOnStopIfNecessary(Object obj, int i, Activity activity) {
+        try {
+            final Object obj2 = tokenField.get(activity);
+            if (obj2 == obj && activity.hashCode() == i) {
+                final Object obj3 = mainThreadField.get(activity);
+                mainHandler.postAtFrontOfQueue(new Runnable() { // from class: androidx.core.app.ActivityRecreator.3
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        try {
+                            Method method = ActivityRecreator.performStopActivity3ParamsMethod;
+                            if (method != null) {
+                                method.invoke(obj3, obj2, Boolean.FALSE, "AppCompat recreation");
+                            } else {
+                                ActivityRecreator.performStopActivity2ParamsMethod.invoke(obj3, obj2, Boolean.FALSE);
+                            }
+                        } catch (RuntimeException e) {
+                            if (e.getClass() == RuntimeException.class && e.getMessage() != null && e.getMessage().startsWith("Unable to stop")) {
+                                throw e;
+                            }
+                        } catch (Throwable th) {
+                            Log.e(ActivityRecreator.LOG_TAG, "Exception while invoking performStopActivity", th);
+                        }
+                    }
+                });
+                return true;
+            }
+            return false;
+        } catch (Throwable th) {
+            Log.e(LOG_TAG, "Exception while fetching field values", th);
+            return false;
+        }
+    }
+
+    private static Method getPerformStopActivity3Params(Class<?> cls) {
+        if (cls == null) {
+            return null;
+        }
+        try {
+            Method declaredMethod = cls.getDeclaredMethod("performStopActivity", IBinder.class, Boolean.TYPE, String.class);
+            declaredMethod.setAccessible(true);
+            return declaredMethod;
+        } catch (Throwable unused) {
+            return null;
+        }
+    }
+
+    private static Method getPerformStopActivity2Params(Class<?> cls) {
+        if (cls == null) {
+            return null;
+        }
+        try {
+            Method declaredMethod = cls.getDeclaredMethod("performStopActivity", IBinder.class, Boolean.TYPE);
+            declaredMethod.setAccessible(true);
+            return declaredMethod;
+        } catch (Throwable unused) {
+            return null;
+        }
+    }
+
+    private static Method getRequestRelaunchActivityMethod(Class<?> cls) {
+        if (needsRelaunchCall() && cls != null) {
+            try {
+                Class<?> cls2 = Boolean.TYPE;
+                Method declaredMethod = cls.getDeclaredMethod("requestRelaunchActivity", IBinder.class, List.class, List.class, Integer.TYPE, cls2, Configuration.class, Configuration.class, cls2, cls2);
+                declaredMethod.setAccessible(true);
+                return declaredMethod;
+            } catch (Throwable unused) {
+            }
+        }
+        return null;
+    }
+
+    private static Field getMainThreadField() {
+        try {
+            Field declaredField = Activity.class.getDeclaredField("mMainThread");
+            declaredField.setAccessible(true);
+            return declaredField;
+        } catch (Throwable unused) {
+            return null;
+        }
+    }
+
+    private static Field getTokenField() {
+        try {
+            Field declaredField = Activity.class.getDeclaredField("mToken");
+            declaredField.setAccessible(true);
+            return declaredField;
+        } catch (Throwable unused) {
+            return null;
+        }
+    }
+
+    private static Class<?> getActivityThreadClass() {
+        try {
+            return Class.forName("android.app.ActivityThread");
+        } catch (Throwable unused) {
+            return null;
+        }
+    }
+}

decompiled/sources/androidx/core/app/AlarmManagerCompat.java

@@ -0,0 +1,79 @@
+package androidx.core.app;
+
+import android.annotation.SuppressLint;
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.os.Build;
+import androidx.annotation.NonNull;
+import androidx.annotation.ReplaceWith;
+import androidx.annotation.RequiresApi;
+
+/* loaded from: classes.dex */
+public final class AlarmManagerCompat {
+    @SuppressLint({"MissingPermission"})
+    public static void setAlarmClock(@NonNull AlarmManager alarmManager, long j, @NonNull PendingIntent pendingIntent, @NonNull PendingIntent pendingIntent2) {
+        Api21Impl.setAlarmClock(alarmManager, Api21Impl.createAlarmClockInfo(j, pendingIntent), pendingIntent2);
+    }
+
+    public static void setAndAllowWhileIdle(@NonNull AlarmManager alarmManager, int i, long j, @NonNull PendingIntent pendingIntent) {
+        Api23Impl.setAndAllowWhileIdle(alarmManager, i, j, pendingIntent);
+    }
+
+    @ReplaceWith(expression = "alarmManager.setExact(type, triggerAtMillis, operation)")
+    @Deprecated
+    public static void setExact(@NonNull AlarmManager alarmManager, int i, long j, @NonNull PendingIntent pendingIntent) {
+        alarmManager.setExact(i, j, pendingIntent);
+    }
+
+    public static void setExactAndAllowWhileIdle(@NonNull AlarmManager alarmManager, int i, long j, @NonNull PendingIntent pendingIntent) {
+        Api23Impl.setExactAndAllowWhileIdle(alarmManager, i, j, pendingIntent);
+    }
+
+    public static boolean canScheduleExactAlarms(@NonNull AlarmManager alarmManager) {
+        if (Build.VERSION.SDK_INT >= 31) {
+            return Api31Impl.canScheduleExactAlarms(alarmManager);
+        }
+        return true;
+    }
+
+    private AlarmManagerCompat() {
+    }
+
+    @RequiresApi(21)
+    public static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        public static void setAlarmClock(AlarmManager alarmManager, Object obj, PendingIntent pendingIntent) {
+            alarmManager.setAlarmClock((AlarmManager.AlarmClockInfo) obj, pendingIntent);
+        }
+
+        public static AlarmManager.AlarmClockInfo createAlarmClockInfo(long j, PendingIntent pendingIntent) {
+            return new AlarmManager.AlarmClockInfo(j, pendingIntent);
+        }
+    }
+
+    @RequiresApi(23)
+    public static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        public static void setAndAllowWhileIdle(AlarmManager alarmManager, int i, long j, PendingIntent pendingIntent) {
+            alarmManager.setAndAllowWhileIdle(i, j, pendingIntent);
+        }
+
+        public static void setExactAndAllowWhileIdle(AlarmManager alarmManager, int i, long j, PendingIntent pendingIntent) {
+            alarmManager.setExactAndAllowWhileIdle(i, j, pendingIntent);
+        }
+    }
+
+    @RequiresApi(31)
+    public static class Api31Impl {
+        private Api31Impl() {
+        }
+
+        public static boolean canScheduleExactAlarms(AlarmManager alarmManager) {
+            return alarmManager.canScheduleExactAlarms();
+        }
+    }
+}

decompiled/sources/androidx/core/app/AppComponentFactory.java

@@ -0,0 +1,86 @@
+package androidx.core.app;
+
+import android.app.Activity;
+import android.app.Application;
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.ContentProvider;
+import android.content.Intent;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import java.lang.reflect.InvocationTargetException;
+
+@RequiresApi(28)
+/* loaded from: classes.dex */
+public class AppComponentFactory extends android.app.AppComponentFactory {
+    @NonNull
+    public final Activity instantiateActivity(@NonNull ClassLoader classLoader, @NonNull String str, @Nullable Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (Activity) CoreComponentFactory.checkCompatWrapper(instantiateActivityCompat(classLoader, str, intent));
+    }
+
+    @NonNull
+    public final Application instantiateApplication(@NonNull ClassLoader classLoader, @NonNull String str) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (Application) CoreComponentFactory.checkCompatWrapper(instantiateApplicationCompat(classLoader, str));
+    }
+
+    @NonNull
+    public final BroadcastReceiver instantiateReceiver(@NonNull ClassLoader classLoader, @NonNull String str, @Nullable Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (BroadcastReceiver) CoreComponentFactory.checkCompatWrapper(instantiateReceiverCompat(classLoader, str, intent));
+    }
+
+    @NonNull
+    public final ContentProvider instantiateProvider(@NonNull ClassLoader classLoader, @NonNull String str) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (ContentProvider) CoreComponentFactory.checkCompatWrapper(instantiateProviderCompat(classLoader, str));
+    }
+
+    @NonNull
+    public final Service instantiateService(@NonNull ClassLoader classLoader, @NonNull String str, @Nullable Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (Service) CoreComponentFactory.checkCompatWrapper(instantiateServiceCompat(classLoader, str, intent));
+    }
+
+    @NonNull
+    public Application instantiateApplicationCompat(@NonNull ClassLoader classLoader, @NonNull String str) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        try {
+            return (Application) Class.forName(str, false, classLoader).asSubclass(Application.class).getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (NoSuchMethodException | InvocationTargetException e) {
+            throw new RuntimeException("Couldn't call constructor", e);
+        }
+    }
+
+    @NonNull
+    public Activity instantiateActivityCompat(@NonNull ClassLoader classLoader, @NonNull String str, @Nullable Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        try {
+            return (Activity) Class.forName(str, false, classLoader).asSubclass(Activity.class).getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (NoSuchMethodException | InvocationTargetException e) {
+            throw new RuntimeException("Couldn't call constructor", e);
+        }
+    }
+
+    @NonNull
+    public BroadcastReceiver instantiateReceiverCompat(@NonNull ClassLoader classLoader, @NonNull String str, @Nullable Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        try {
+            return (BroadcastReceiver) Class.forName(str, false, classLoader).asSubclass(BroadcastReceiver.class).getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (NoSuchMethodException | InvocationTargetException e) {
+            throw new RuntimeException("Couldn't call constructor", e);
+        }
+    }
+
+    @NonNull
+    public Service instantiateServiceCompat(@NonNull ClassLoader classLoader, @NonNull String str, @Nullable Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        try {
+            return (Service) Class.forName(str, false, classLoader).asSubclass(Service.class).getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (NoSuchMethodException | InvocationTargetException e) {
+            throw new RuntimeException("Couldn't call constructor", e);
+        }
+    }
+
+    @NonNull
+    public ContentProvider instantiateProviderCompat(@NonNull ClassLoader classLoader, @NonNull String str) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        try {
+            return (ContentProvider) Class.forName(str, false, classLoader).asSubclass(ContentProvider.class).getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (NoSuchMethodException | InvocationTargetException e) {
+            throw new RuntimeException("Couldn't call constructor", e);
+        }
+    }
+}

decompiled/sources/androidx/core/app/AppLaunchChecker.java

@@ -0,0 +1,35 @@
+package androidx.core.app;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import androidx.annotation.NonNull;
+import androidx.core.content.IntentCompat;
+
+@SuppressLint({"PrivateConstructorForUtilityClass"})
+/* loaded from: classes.dex */
+public class AppLaunchChecker {
+    private static final String KEY_STARTED_FROM_LAUNCHER = "startedFromLauncher";
+    private static final String SHARED_PREFS_NAME = "android.support.AppLaunchChecker";
+
+    public static boolean hasStartedFromLauncher(@NonNull Context context) {
+        return context.getSharedPreferences(SHARED_PREFS_NAME, 0).getBoolean(KEY_STARTED_FROM_LAUNCHER, false);
+    }
+
+    public static void onActivityCreate(@NonNull Activity activity) {
+        Intent intent;
+        SharedPreferences sharedPreferences = activity.getSharedPreferences(SHARED_PREFS_NAME, 0);
+        if (sharedPreferences.getBoolean(KEY_STARTED_FROM_LAUNCHER, false) || (intent = activity.getIntent()) == null || !"android.intent.action.MAIN".equals(intent.getAction())) {
+            return;
+        }
+        if (intent.hasCategory("android.intent.category.LAUNCHER") || intent.hasCategory(IntentCompat.CATEGORY_LEANBACK_LAUNCHER)) {
+            sharedPreferences.edit().putBoolean(KEY_STARTED_FROM_LAUNCHER, true).apply();
+        }
+    }
+
+    @Deprecated
+    public AppLaunchChecker() {
+    }
+}

decompiled/sources/androidx/core/app/AppLocalesStorageHelper.java

@@ -0,0 +1,208 @@
+package androidx.core.app;
+
+import androidx.annotation.RestrictTo;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public class AppLocalesStorageHelper {
+    static final String APPLICATION_LOCALES_RECORD_FILE = "androidx.appcompat.app.AppCompatDelegate.application_locales_record_file";
+    static final boolean DEBUG = false;
+    static final String LOCALE_RECORD_ATTRIBUTE_TAG = "application_locales";
+    static final String LOCALE_RECORD_FILE_TAG = "locales";
+    static final String TAG = "AppLocalesStorageHelper";
+    private static final Object sAppLocaleStorageSync = new Object();
+
+    private AppLocalesStorageHelper() {
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:16:0x0044, code lost:
+    
+        if (r2 != null) goto L48;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:25:0x0046, code lost:
+    
+        r2.close();
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:31:0x002e, code lost:
+    
+        if (r5 != 4) goto L57;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:34:0x003b, code lost:
+    
+        if (r3.getName().equals(androidx.core.app.AppLocalesStorageHelper.LOCALE_RECORD_FILE_TAG) == false) goto L62;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:36:0x003d, code lost:
+    
+        r1 = r3.getAttributeValue(null, androidx.core.app.AppLocalesStorageHelper.LOCALE_RECORD_ATTRIBUTE_TAG);
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:54:0x0053, code lost:
+    
+        if (r2 == null) goto L31;
+     */
+    @androidx.annotation.NonNull
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static java.lang.String readLocales(@androidx.annotation.NonNull android.content.Context r8) {
+        /*
+            java.lang.Object r0 = androidx.core.app.AppLocalesStorageHelper.sAppLocaleStorageSync
+            monitor-enter(r0)
+            java.lang.String r1 = ""
+            java.lang.String r2 = "androidx.appcompat.app.AppCompatDelegate.application_locales_record_file"
+            java.io.FileInputStream r2 = r8.openFileInput(r2)     // Catch: java.lang.Throwable -> L4a java.io.FileNotFoundException -> L6a
+            org.xmlpull.v1.XmlPullParser r3 = android.util.Xml.newPullParser()     // Catch: java.lang.Throwable -> L29 java.lang.Throwable -> L4c
+            java.lang.String r4 = "UTF-8"
+            r3.setInput(r2, r4)     // Catch: java.lang.Throwable -> L29 java.lang.Throwable -> L4c
+            int r4 = r3.getDepth()     // Catch: java.lang.Throwable -> L29 java.lang.Throwable -> L4c
+        L18:
+            int r5 = r3.next()     // Catch: java.lang.Throwable -> L29 java.lang.Throwable -> L4c
+            r6 = 1
+            if (r5 == r6) goto L44
+            r6 = 3
+            if (r5 != r6) goto L2b
+            int r7 = r3.getDepth()     // Catch: java.lang.Throwable -> L29 java.lang.Throwable -> L4c
+            if (r7 <= r4) goto L44
+            goto L2b
+        L29:
+            r8 = move-exception
+            goto L64
+        L2b:
+            if (r5 == r6) goto L18
+            r6 = 4
+            if (r5 != r6) goto L31
+            goto L18
+        L31:
+            java.lang.String r5 = r3.getName()     // Catch: java.lang.Throwable -> L29 java.lang.Throwable -> L4c
+            java.lang.String r6 = "locales"
+            boolean r5 = r5.equals(r6)     // Catch: java.lang.Throwable -> L29 java.lang.Throwable -> L4c
+            if (r5 == 0) goto L18
+            java.lang.String r4 = "application_locales"
+            r5 = 0
+            java.lang.String r1 = r3.getAttributeValue(r5, r4)     // Catch: java.lang.Throwable -> L29 java.lang.Throwable -> L4c
+        L44:
+            if (r2 == 0) goto L56
+        L46:
+            r2.close()     // Catch: java.lang.Throwable -> L4a java.io.IOException -> L56
+            goto L56
+        L4a:
+            r8 = move-exception
+            goto L6c
+        L4c:
+            java.lang.String r3 = "AppLocalesStorageHelper"
+            java.lang.String r4 = "Reading app Locales : Unable to parse through file :androidx.appcompat.app.AppCompatDelegate.application_locales_record_file"
+            android.util.Log.w(r3, r4)     // Catch: java.lang.Throwable -> L29
+            if (r2 == 0) goto L56
+            goto L46
+        L56:
+            boolean r2 = r1.isEmpty()     // Catch: java.lang.Throwable -> L4a
+            if (r2 != 0) goto L5d
+            goto L62
+        L5d:
+            java.lang.String r2 = "androidx.appcompat.app.AppCompatDelegate.application_locales_record_file"
+            r8.deleteFile(r2)     // Catch: java.lang.Throwable -> L4a
+        L62:
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L4a
+            return r1
+        L64:
+            if (r2 == 0) goto L69
+            r2.close()     // Catch: java.lang.Throwable -> L4a java.io.IOException -> L69
+        L69:
+            throw r8     // Catch: java.lang.Throwable -> L4a
+        L6a:
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L4a
+            return r1
+        L6c:
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L4a
+            throw r8
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.core.app.AppLocalesStorageHelper.readLocales(android.content.Context):java.lang.String");
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:17:0x003c, code lost:
+    
+        if (r5 != null) goto L41;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:21:0x003e, code lost:
+    
+        r5.close();
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:34:0x004c, code lost:
+    
+        if (r5 == null) goto L25;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static void persistLocales(@androidx.annotation.NonNull android.content.Context r5, @androidx.annotation.NonNull java.lang.String r6) {
+        /*
+            java.lang.Object r0 = androidx.core.app.AppLocalesStorageHelper.sAppLocaleStorageSync
+            monitor-enter(r0)
+            java.lang.String r1 = ""
+            boolean r1 = r6.equals(r1)     // Catch: java.lang.Throwable -> L12
+            if (r1 == 0) goto L14
+            java.lang.String r6 = "androidx.appcompat.app.AppCompatDelegate.application_locales_record_file"
+            r5.deleteFile(r6)     // Catch: java.lang.Throwable -> L12
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L12
+            return
+        L12:
+            r5 = move-exception
+            goto L6b
+        L14:
+            r1 = 0
+            java.lang.String r2 = "androidx.appcompat.app.AppCompatDelegate.application_locales_record_file"
+            java.io.FileOutputStream r5 = r5.openFileOutput(r2, r1)     // Catch: java.lang.Throwable -> L12 java.io.FileNotFoundException -> L57
+            org.xmlpull.v1.XmlSerializer r1 = android.util.Xml.newSerializer()     // Catch: java.lang.Throwable -> L12
+            r2 = 0
+            r1.setOutput(r5, r2)     // Catch: java.lang.Throwable -> L42 java.lang.Exception -> L44
+            java.lang.String r3 = "UTF-8"
+            java.lang.Boolean r4 = java.lang.Boolean.TRUE     // Catch: java.lang.Throwable -> L42 java.lang.Exception -> L44
+            r1.startDocument(r3, r4)     // Catch: java.lang.Throwable -> L42 java.lang.Exception -> L44
+            java.lang.String r3 = "locales"
+            r1.startTag(r2, r3)     // Catch: java.lang.Throwable -> L42 java.lang.Exception -> L44
+            java.lang.String r3 = "application_locales"
+            r1.attribute(r2, r3, r6)     // Catch: java.lang.Throwable -> L42 java.lang.Exception -> L44
+            java.lang.String r6 = "locales"
+            r1.endTag(r2, r6)     // Catch: java.lang.Throwable -> L42 java.lang.Exception -> L44
+            r1.endDocument()     // Catch: java.lang.Throwable -> L42 java.lang.Exception -> L44
+            if (r5 == 0) goto L4f
+        L3e:
+            r5.close()     // Catch: java.lang.Throwable -> L12 java.io.IOException -> L4f
+            goto L4f
+        L42:
+            r6 = move-exception
+            goto L51
+        L44:
+            r6 = move-exception
+            java.lang.String r1 = "AppLocalesStorageHelper"
+            java.lang.String r2 = "Storing App Locales : Failed to persist app-locales in storage "
+            android.util.Log.w(r1, r2, r6)     // Catch: java.lang.Throwable -> L42
+            if (r5 == 0) goto L4f
+            goto L3e
+        L4f:
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L12
+            return
+        L51:
+            if (r5 == 0) goto L56
+            r5.close()     // Catch: java.lang.Throwable -> L12 java.io.IOException -> L56
+        L56:
+            throw r6     // Catch: java.lang.Throwable -> L12
+        L57:
+            java.lang.String r5 = "AppLocalesStorageHelper"
+            java.lang.String r6 = "Storing App Locales : FileNotFoundException: Cannot open file %s for writing "
+            r2 = 1
+            java.lang.Object[] r2 = new java.lang.Object[r2]     // Catch: java.lang.Throwable -> L12
+            java.lang.String r3 = "androidx.appcompat.app.AppCompatDelegate.application_locales_record_file"
+            r2[r1] = r3     // Catch: java.lang.Throwable -> L12
+            java.lang.String r6 = java.lang.String.format(r6, r2)     // Catch: java.lang.Throwable -> L12
+            android.util.Log.w(r5, r6)     // Catch: java.lang.Throwable -> L12
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L12
+            return
+        L6b:
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L12
+            throw r5
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.core.app.AppLocalesStorageHelper.persistLocales(android.content.Context, java.lang.String):void");
+    }
+}

decompiled/sources/androidx/core/app/AppOpsManagerCompat.java

@@ -0,0 +1,95 @@
+package androidx.core.app;
+
+import android.app.AppOpsManager;
+import android.content.Context;
+import android.os.Binder;
+import android.os.Build;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+/* loaded from: classes.dex */
+public final class AppOpsManagerCompat {
+    public static final int MODE_ALLOWED = 0;
+    public static final int MODE_DEFAULT = 3;
+    public static final int MODE_ERRORED = 2;
+    public static final int MODE_IGNORED = 1;
+
+    private AppOpsManagerCompat() {
+    }
+
+    @Nullable
+    public static String permissionToOp(@NonNull String str) {
+        return Api23Impl.permissionToOp(str);
+    }
+
+    public static int noteOp(@NonNull Context context, @NonNull String str, int i, @NonNull String str2) {
+        return ((AppOpsManager) context.getSystemService("appops")).noteOp(str, i, str2);
+    }
+
+    public static int noteOpNoThrow(@NonNull Context context, @NonNull String str, int i, @NonNull String str2) {
+        return ((AppOpsManager) context.getSystemService("appops")).noteOpNoThrow(str, i, str2);
+    }
+
+    public static int noteProxyOp(@NonNull Context context, @NonNull String str, @NonNull String str2) {
+        return Api23Impl.noteProxyOp((AppOpsManager) Api23Impl.getSystemService(context, AppOpsManager.class), str, str2);
+    }
+
+    public static int noteProxyOpNoThrow(@NonNull Context context, @NonNull String str, @NonNull String str2) {
+        return Api23Impl.noteProxyOpNoThrow((AppOpsManager) Api23Impl.getSystemService(context, AppOpsManager.class), str, str2);
+    }
+
+    public static int checkOrNoteProxyOp(@NonNull Context context, int i, @NonNull String str, @NonNull String str2) {
+        if (Build.VERSION.SDK_INT >= 29) {
+            AppOpsManager systemService = Api29Impl.getSystemService(context);
+            int checkOpNoThrow = Api29Impl.checkOpNoThrow(systemService, str, Binder.getCallingUid(), str2);
+            return checkOpNoThrow != 0 ? checkOpNoThrow : Api29Impl.checkOpNoThrow(systemService, str, i, Api29Impl.getOpPackageName(context));
+        }
+        return noteProxyOpNoThrow(context, str, str2);
+    }
+
+    @RequiresApi(29)
+    public static class Api29Impl {
+        private Api29Impl() {
+        }
+
+        @Nullable
+        public static AppOpsManager getSystemService(@NonNull Context context) {
+            return (AppOpsManager) context.getSystemService(AppOpsManager.class);
+        }
+
+        public static int checkOpNoThrow(@Nullable AppOpsManager appOpsManager, @NonNull String str, int i, @NonNull String str2) {
+            if (appOpsManager == null) {
+                return 1;
+            }
+            return appOpsManager.checkOpNoThrow(str, i, str2);
+        }
+
+        @NonNull
+        public static String getOpPackageName(@NonNull Context context) {
+            return context.getOpPackageName();
+        }
+    }
+
+    @RequiresApi(23)
+    public static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        public static String permissionToOp(String str) {
+            return AppOpsManager.permissionToOp(str);
+        }
+
+        public static <T> T getSystemService(Context context, Class<T> cls) {
+            return (T) context.getSystemService(cls);
+        }
+
+        public static int noteProxyOp(AppOpsManager appOpsManager, String str, String str2) {
+            return appOpsManager.noteProxyOp(str, str2);
+        }
+
+        public static int noteProxyOpNoThrow(AppOpsManager appOpsManager, String str, String str2) {
+            return appOpsManager.noteProxyOpNoThrow(str, str2);
+        }
+    }
+}

decompiled/sources/androidx/core/app/BundleCompat.java

@@ -0,0 +1,27 @@
+package androidx.core.app;
+
+import android.os.Bundle;
+import android.os.IBinder;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.ReplaceWith;
+
+@Deprecated
+/* loaded from: classes.dex */
+public final class BundleCompat {
+    private BundleCompat() {
+    }
+
+    @Nullable
+    @ReplaceWith(expression = "bundle.getBinder(key)")
+    @Deprecated
+    public static IBinder getBinder(@NonNull Bundle bundle, @Nullable String str) {
+        return bundle.getBinder(str);
+    }
+
+    @ReplaceWith(expression = "bundle.putBinder(key, binder)")
+    @Deprecated
+    public static void putBinder(@NonNull Bundle bundle, @Nullable String str, @Nullable IBinder iBinder) {
+        bundle.putBinder(str, iBinder);
+    }
+}

decompiled/sources/androidx/core/app/ComponentActivity.java

@@ -0,0 +1,125 @@
+package androidx.core.app;
+
+import android.app.Activity;
+import android.os.Build;
+import android.os.Bundle;
+import android.view.KeyEvent;
+import android.view.View;
+import androidx.annotation.CallSuper;
+import androidx.annotation.RestrictTo;
+import androidx.collection.SimpleArrayMap;
+import androidx.core.view.KeyEventDispatcher;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.LifecycleRegistry;
+import androidx.lifecycle.ReportFragment;
+import kotlin.jvm.internal.Intrinsics;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public class ComponentActivity extends Activity implements LifecycleOwner, KeyEventDispatcher.Component {
+    private final SimpleArrayMap<Class<? extends ExtraData>, ExtraData> extraDataMap = new SimpleArrayMap<>(0, 1, null);
+    private final LifecycleRegistry lifecycleRegistry = new LifecycleRegistry(this);
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static class ExtraData {
+    }
+
+    private static /* synthetic */ void getExtraDataMap$annotations() {
+    }
+
+    private static /* synthetic */ void getLifecycleRegistry$annotations() {
+    }
+
+    public Lifecycle getLifecycle() {
+        return this.lifecycleRegistry;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public void putExtraData(ExtraData extraData) {
+        Intrinsics.checkNotNullParameter(extraData, "extraData");
+        this.extraDataMap.put(extraData.getClass(), extraData);
+    }
+
+    @Override // android.app.Activity
+    public void onCreate(Bundle bundle) {
+        super.onCreate(bundle);
+        ReportFragment.Companion.injectIfNeededIn(this);
+    }
+
+    @Override // android.app.Activity
+    @CallSuper
+    public void onSaveInstanceState(Bundle outState) {
+        Intrinsics.checkNotNullParameter(outState, "outState");
+        this.lifecycleRegistry.setCurrentState(Lifecycle.State.CREATED);
+        super.onSaveInstanceState(outState);
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public <T extends ExtraData> T getExtraData(Class<T> extraDataClass) {
+        Intrinsics.checkNotNullParameter(extraDataClass, "extraDataClass");
+        return (T) this.extraDataMap.get(extraDataClass);
+    }
+
+    @Override // androidx.core.view.KeyEventDispatcher.Component
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public boolean superDispatchKeyEvent(KeyEvent event) {
+        Intrinsics.checkNotNullParameter(event, "event");
+        return super.dispatchKeyEvent(event);
+    }
+
+    @Override // android.app.Activity, android.view.Window.Callback
+    public boolean dispatchKeyShortcutEvent(KeyEvent event) {
+        Intrinsics.checkNotNullParameter(event, "event");
+        View decorView = getWindow().getDecorView();
+        Intrinsics.checkNotNullExpressionValue(decorView, "window.decorView");
+        if (KeyEventDispatcher.dispatchBeforeHierarchy(decorView, event)) {
+            return true;
+        }
+        return super.dispatchKeyShortcutEvent(event);
+    }
+
+    @Override // android.app.Activity, android.view.Window.Callback
+    public boolean dispatchKeyEvent(KeyEvent event) {
+        Intrinsics.checkNotNullParameter(event, "event");
+        View decorView = getWindow().getDecorView();
+        Intrinsics.checkNotNullExpressionValue(decorView, "window.decorView");
+        if (KeyEventDispatcher.dispatchBeforeHierarchy(decorView, event)) {
+            return true;
+        }
+        return KeyEventDispatcher.dispatchKeyEvent(this, decorView, this, event);
+    }
+
+    public final boolean shouldDumpInternalState(String[] strArr) {
+        return !shouldSkipDump(strArr);
+    }
+
+    private final boolean shouldSkipDump(String[] strArr) {
+        if (strArr == null || strArr.length == 0) {
+            return false;
+        }
+        String str = strArr[0];
+        switch (str.hashCode()) {
+            case -645125871:
+                return str.equals("--translation") && Build.VERSION.SDK_INT >= 31;
+            case 100470631:
+                if (!str.equals("--dump-dumpable")) {
+                    return false;
+                }
+                break;
+            case 472614934:
+                if (!str.equals("--list-dumpables")) {
+                    return false;
+                }
+                break;
+            case 1159329357:
+                return str.equals("--contentcapture") && Build.VERSION.SDK_INT >= 29;
+            case 1455016274:
+                return str.equals("--autofill");
+            default:
+                return false;
+        }
+        return Build.VERSION.SDK_INT >= 33;
+    }
+}

decompiled/sources/androidx/core/app/CoreComponentFactory.java

@@ -0,0 +1,53 @@
+package androidx.core.app;
+
+import android.app.Activity;
+import android.app.Application;
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.ContentProvider;
+import android.content.Intent;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+
+@RequiresApi(api = 28)
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public class CoreComponentFactory extends android.app.AppComponentFactory {
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public interface CompatWrapped {
+        Object getWrapper();
+    }
+
+    @NonNull
+    public Activity instantiateActivity(@NonNull ClassLoader classLoader, @NonNull String str, @Nullable Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (Activity) checkCompatWrapper(super.instantiateActivity(classLoader, str, intent));
+    }
+
+    @NonNull
+    public Application instantiateApplication(@NonNull ClassLoader classLoader, @NonNull String str) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (Application) checkCompatWrapper(super.instantiateApplication(classLoader, str));
+    }
+
+    @NonNull
+    public BroadcastReceiver instantiateReceiver(@NonNull ClassLoader classLoader, @NonNull String str, @Nullable Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (BroadcastReceiver) checkCompatWrapper(super.instantiateReceiver(classLoader, str, intent));
+    }
+
+    @NonNull
+    public ContentProvider instantiateProvider(@NonNull ClassLoader classLoader, @NonNull String str) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (ContentProvider) checkCompatWrapper(super.instantiateProvider(classLoader, str));
+    }
+
+    @NonNull
+    public Service instantiateService(@NonNull ClassLoader classLoader, @NonNull String str, @Nullable Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (Service) checkCompatWrapper(super.instantiateService(classLoader, str, intent));
+    }
+
+    public static <T> T checkCompatWrapper(T t) {
+        T t2;
+        return (!(t instanceof CompatWrapped) || (t2 = (T) ((CompatWrapped) t).getWrapper()) == null) ? t : t2;
+    }
+}

decompiled/sources/androidx/core/app/DialogCompat.java

@@ -0,0 +1,35 @@
+package androidx.core.app;
+
+import android.app.Dialog;
+import android.os.Build;
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+/* loaded from: classes.dex */
+public class DialogCompat {
+    private DialogCompat() {
+    }
+
+    @NonNull
+    public static View requireViewById(@NonNull Dialog dialog, int i) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return (View) Api28Impl.requireViewById(dialog, i);
+        }
+        View findViewById = dialog.findViewById(i);
+        if (findViewById != null) {
+            return findViewById;
+        }
+        throw new IllegalArgumentException("ID does not reference a View inside this Dialog");
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static <T> T requireViewById(Dialog dialog, int i) {
+            return (T) dialog.requireViewById(i);
+        }
+    }
+}

decompiled/sources/androidx/core/app/FrameMetricsAggregator.java

@@ -0,0 +1,225 @@
+package androidx.core.app;
+
+import android.app.Activity;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.util.SparseIntArray;
+import android.view.FrameMetrics;
+import android.view.Window;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public class FrameMetricsAggregator {
+    public static final int ANIMATION_DURATION = 256;
+    public static final int ANIMATION_INDEX = 8;
+    public static final int COMMAND_DURATION = 32;
+    public static final int COMMAND_INDEX = 5;
+    public static final int DELAY_DURATION = 128;
+    public static final int DELAY_INDEX = 7;
+    public static final int DRAW_DURATION = 8;
+    public static final int DRAW_INDEX = 3;
+    public static final int EVERY_DURATION = 511;
+    public static final int INPUT_DURATION = 2;
+    public static final int INPUT_INDEX = 1;
+    private static final int LAST_INDEX = 8;
+    public static final int LAYOUT_MEASURE_DURATION = 4;
+    public static final int LAYOUT_MEASURE_INDEX = 2;
+    public static final int SWAP_DURATION = 64;
+    public static final int SWAP_INDEX = 6;
+    public static final int SYNC_DURATION = 16;
+    public static final int SYNC_INDEX = 4;
+    public static final int TOTAL_DURATION = 1;
+    public static final int TOTAL_INDEX = 0;
+    private final FrameMetricsBaseImpl mInstance;
+
+    public static class FrameMetricsBaseImpl {
+        public void add(Activity activity) {
+        }
+
+        public SparseIntArray[] getMetrics() {
+            return null;
+        }
+
+        public SparseIntArray[] remove(Activity activity) {
+            return null;
+        }
+
+        public SparseIntArray[] reset() {
+            return null;
+        }
+
+        public SparseIntArray[] stop() {
+            return null;
+        }
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public @interface MetricType {
+    }
+
+    public FrameMetricsAggregator() {
+        this(1);
+    }
+
+    public FrameMetricsAggregator(int i) {
+        this.mInstance = new FrameMetricsApi24Impl(i);
+    }
+
+    public void add(@NonNull Activity activity) {
+        this.mInstance.add(activity);
+    }
+
+    @Nullable
+    public SparseIntArray[] remove(@NonNull Activity activity) {
+        return this.mInstance.remove(activity);
+    }
+
+    @Nullable
+    public SparseIntArray[] stop() {
+        return this.mInstance.stop();
+    }
+
+    @Nullable
+    public SparseIntArray[] reset() {
+        return this.mInstance.reset();
+    }
+
+    @Nullable
+    public SparseIntArray[] getMetrics() {
+        return this.mInstance.getMetrics();
+    }
+
+    @RequiresApi(24)
+    public static class FrameMetricsApi24Impl extends FrameMetricsBaseImpl {
+        private static final int NANOS_PER_MS = 1000000;
+        private static final int NANOS_ROUNDING_VALUE = 500000;
+        private static Handler sHandler;
+        private static HandlerThread sHandlerThread;
+        int mTrackingFlags;
+        SparseIntArray[] mMetrics = new SparseIntArray[9];
+        private final ArrayList<WeakReference<Activity>> mActivities = new ArrayList<>();
+        Window.OnFrameMetricsAvailableListener mListener = new Window.OnFrameMetricsAvailableListener() { // from class: androidx.core.app.FrameMetricsAggregator.FrameMetricsApi24Impl.1
+            @Override // android.view.Window.OnFrameMetricsAvailableListener
+            public void onFrameMetricsAvailable(Window window, FrameMetrics frameMetrics, int i) {
+                FrameMetricsApi24Impl frameMetricsApi24Impl = FrameMetricsApi24Impl.this;
+                if ((frameMetricsApi24Impl.mTrackingFlags & 1) != 0) {
+                    frameMetricsApi24Impl.addDurationItem(frameMetricsApi24Impl.mMetrics[0], frameMetrics.getMetric(8));
+                }
+                FrameMetricsApi24Impl frameMetricsApi24Impl2 = FrameMetricsApi24Impl.this;
+                if ((frameMetricsApi24Impl2.mTrackingFlags & 2) != 0) {
+                    frameMetricsApi24Impl2.addDurationItem(frameMetricsApi24Impl2.mMetrics[1], frameMetrics.getMetric(1));
+                }
+                FrameMetricsApi24Impl frameMetricsApi24Impl3 = FrameMetricsApi24Impl.this;
+                if ((frameMetricsApi24Impl3.mTrackingFlags & 4) != 0) {
+                    frameMetricsApi24Impl3.addDurationItem(frameMetricsApi24Impl3.mMetrics[2], frameMetrics.getMetric(3));
+                }
+                FrameMetricsApi24Impl frameMetricsApi24Impl4 = FrameMetricsApi24Impl.this;
+                if ((frameMetricsApi24Impl4.mTrackingFlags & 8) != 0) {
+                    frameMetricsApi24Impl4.addDurationItem(frameMetricsApi24Impl4.mMetrics[3], frameMetrics.getMetric(4));
+                }
+                FrameMetricsApi24Impl frameMetricsApi24Impl5 = FrameMetricsApi24Impl.this;
+                if ((frameMetricsApi24Impl5.mTrackingFlags & 16) != 0) {
+                    frameMetricsApi24Impl5.addDurationItem(frameMetricsApi24Impl5.mMetrics[4], frameMetrics.getMetric(5));
+                }
+                FrameMetricsApi24Impl frameMetricsApi24Impl6 = FrameMetricsApi24Impl.this;
+                if ((frameMetricsApi24Impl6.mTrackingFlags & 64) != 0) {
+                    frameMetricsApi24Impl6.addDurationItem(frameMetricsApi24Impl6.mMetrics[6], frameMetrics.getMetric(7));
+                }
+                FrameMetricsApi24Impl frameMetricsApi24Impl7 = FrameMetricsApi24Impl.this;
+                if ((frameMetricsApi24Impl7.mTrackingFlags & 32) != 0) {
+                    frameMetricsApi24Impl7.addDurationItem(frameMetricsApi24Impl7.mMetrics[5], frameMetrics.getMetric(6));
+                }
+                FrameMetricsApi24Impl frameMetricsApi24Impl8 = FrameMetricsApi24Impl.this;
+                if ((frameMetricsApi24Impl8.mTrackingFlags & 128) != 0) {
+                    frameMetricsApi24Impl8.addDurationItem(frameMetricsApi24Impl8.mMetrics[7], frameMetrics.getMetric(0));
+                }
+                FrameMetricsApi24Impl frameMetricsApi24Impl9 = FrameMetricsApi24Impl.this;
+                if ((frameMetricsApi24Impl9.mTrackingFlags & 256) != 0) {
+                    frameMetricsApi24Impl9.addDurationItem(frameMetricsApi24Impl9.mMetrics[8], frameMetrics.getMetric(2));
+                }
+            }
+        };
+
+        @Override // androidx.core.app.FrameMetricsAggregator.FrameMetricsBaseImpl
+        public SparseIntArray[] getMetrics() {
+            return this.mMetrics;
+        }
+
+        @Override // androidx.core.app.FrameMetricsAggregator.FrameMetricsBaseImpl
+        public SparseIntArray[] reset() {
+            SparseIntArray[] sparseIntArrayArr = this.mMetrics;
+            this.mMetrics = new SparseIntArray[9];
+            return sparseIntArrayArr;
+        }
+
+        public FrameMetricsApi24Impl(int i) {
+            this.mTrackingFlags = i;
+        }
+
+        public void addDurationItem(SparseIntArray sparseIntArray, long j) {
+            if (sparseIntArray != null) {
+                int i = (int) ((500000 + j) / 1000000);
+                if (j >= 0) {
+                    sparseIntArray.put(i, sparseIntArray.get(i) + 1);
+                }
+            }
+        }
+
+        @Override // androidx.core.app.FrameMetricsAggregator.FrameMetricsBaseImpl
+        public void add(Activity activity) {
+            if (sHandlerThread == null) {
+                HandlerThread handlerThread = new HandlerThread("FrameMetricsAggregator");
+                sHandlerThread = handlerThread;
+                handlerThread.start();
+                sHandler = new Handler(sHandlerThread.getLooper());
+            }
+            for (int i = 0; i <= 8; i++) {
+                SparseIntArray[] sparseIntArrayArr = this.mMetrics;
+                if (sparseIntArrayArr[i] == null && (this.mTrackingFlags & (1 << i)) != 0) {
+                    sparseIntArrayArr[i] = new SparseIntArray();
+                }
+            }
+            activity.getWindow().addOnFrameMetricsAvailableListener(this.mListener, sHandler);
+            this.mActivities.add(new WeakReference<>(activity));
+        }
+
+        @Override // androidx.core.app.FrameMetricsAggregator.FrameMetricsBaseImpl
+        public SparseIntArray[] remove(Activity activity) {
+            Iterator<WeakReference<Activity>> it = this.mActivities.iterator();
+            while (true) {
+                if (!it.hasNext()) {
+                    break;
+                }
+                WeakReference<Activity> next = it.next();
+                if (next.get() == activity) {
+                    this.mActivities.remove(next);
+                    break;
+                }
+            }
+            activity.getWindow().removeOnFrameMetricsAvailableListener(this.mListener);
+            return this.mMetrics;
+        }
+
+        @Override // androidx.core.app.FrameMetricsAggregator.FrameMetricsBaseImpl
+        public SparseIntArray[] stop() {
+            for (int size = this.mActivities.size() - 1; size >= 0; size--) {
+                WeakReference<Activity> weakReference = this.mActivities.get(size);
+                Activity activity = weakReference.get();
+                if (weakReference.get() != null) {
+                    activity.getWindow().removeOnFrameMetricsAvailableListener(this.mListener);
+                    this.mActivities.remove(size);
+                }
+            }
+            return this.mMetrics;
+        }
+    }
+}

decompiled/sources/androidx/core/app/GrammaticalInflectionManagerCompat.java

@@ -0,0 +1,64 @@
+package androidx.core.app;
+
+import android.app.GrammaticalInflectionManager;
+import android.content.Context;
+import android.os.Build;
+import androidx.annotation.AnyThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.OptIn;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.core.os.BuildCompat;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes.dex */
+public final class GrammaticalInflectionManagerCompat {
+    public static final int GRAMMATICAL_GENDER_FEMININE = 2;
+    public static final int GRAMMATICAL_GENDER_MASCULINE = 3;
+    public static final int GRAMMATICAL_GENDER_NEUTRAL = 1;
+    public static final int GRAMMATICAL_GENDER_NOT_SPECIFIED = 0;
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public @interface GrammaticalGender {
+    }
+
+    private GrammaticalInflectionManagerCompat() {
+    }
+
+    @AnyThread
+    @OptIn(markerClass = {BuildCompat.PrereleaseSdkCheck.class})
+    public static int getApplicationGrammaticalGender(@NonNull Context context) {
+        if (Build.VERSION.SDK_INT >= 34) {
+            return Api34Impl.getApplicationGrammaticalGender(context);
+        }
+        return 0;
+    }
+
+    @AnyThread
+    @OptIn(markerClass = {BuildCompat.PrereleaseSdkCheck.class})
+    public static void setRequestedApplicationGrammaticalGender(@NonNull Context context, int i) {
+        if (Build.VERSION.SDK_INT >= 34) {
+            Api34Impl.setRequestedApplicationGrammaticalGender(context, i);
+        }
+    }
+
+    @RequiresApi(34)
+    public static class Api34Impl {
+        private Api34Impl() {
+        }
+
+        public static int getApplicationGrammaticalGender(Context context) {
+            return getGrammaticalInflectionManager(context).getApplicationGrammaticalGender();
+        }
+
+        public static void setRequestedApplicationGrammaticalGender(Context context, int i) {
+            getGrammaticalInflectionManager(context).setRequestedApplicationGrammaticalGender(i);
+        }
+
+        private static GrammaticalInflectionManager getGrammaticalInflectionManager(Context context) {
+            return (GrammaticalInflectionManager) context.getSystemService(GrammaticalInflectionManager.class);
+        }
+    }
+}

decompiled/sources/androidx/core/app/JobIntentService.java

@@ -0,0 +1,451 @@
+package androidx.core.app;
+
+import android.app.Service;
+import android.app.job.JobInfo;
+import android.app.job.JobParameters;
+import android.app.job.JobScheduler;
+import android.app.job.JobServiceEngine;
+import android.app.job.JobWorkItem;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.os.AsyncTask;
+import android.os.IBinder;
+import android.os.PowerManager;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import com.facebook.AuthenticationTokenClaims;
+import com.mbridge.msdk.playercommon.exoplayer2.source.chunk.ChunkedTrackBlacklistUtil;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+@Deprecated
+/* loaded from: classes.dex */
+public abstract class JobIntentService extends Service {
+    static final boolean DEBUG = false;
+    static final String TAG = "JobIntentService";
+    WorkEnqueuer mCompatWorkEnqueuer;
+    CommandProcessor mCurProcessor;
+    CompatJobEngine mJobImpl;
+    static final Object sLock = new Object();
+    static final HashMap<ComponentName, WorkEnqueuer> sClassWorkEnqueuer = new HashMap<>();
+    boolean mInterruptIfStopped = false;
+    boolean mStopped = false;
+    boolean mDestroyed = false;
+    final ArrayList<CompatWorkItem> mCompatQueue = null;
+
+    public interface CompatJobEngine {
+        IBinder compatGetBinder();
+
+        GenericWorkItem dequeueWork();
+    }
+
+    public interface GenericWorkItem {
+        void complete();
+
+        Intent getIntent();
+    }
+
+    public boolean isStopped() {
+        return this.mStopped;
+    }
+
+    public abstract void onHandleWork(@NonNull Intent intent);
+
+    public boolean onStopCurrentWork() {
+        return true;
+    }
+
+    public void setInterruptIfStopped(boolean z) {
+        this.mInterruptIfStopped = z;
+    }
+
+    public static abstract class WorkEnqueuer {
+        final ComponentName mComponentName;
+        boolean mHasJobId;
+        int mJobId;
+
+        public abstract void enqueueWork(Intent intent);
+
+        public void serviceProcessingFinished() {
+        }
+
+        public void serviceProcessingStarted() {
+        }
+
+        public void serviceStartReceived() {
+        }
+
+        public WorkEnqueuer(ComponentName componentName) {
+            this.mComponentName = componentName;
+        }
+
+        public void ensureJobId(int i) {
+            if (!this.mHasJobId) {
+                this.mHasJobId = true;
+                this.mJobId = i;
+            } else {
+                if (this.mJobId == i) {
+                    return;
+                }
+                throw new IllegalArgumentException("Given job ID " + i + " is different than previous " + this.mJobId);
+            }
+        }
+    }
+
+    public static final class CompatWorkEnqueuer extends WorkEnqueuer {
+        private final Context mContext;
+        private final PowerManager.WakeLock mLaunchWakeLock;
+        boolean mLaunchingService;
+        private final PowerManager.WakeLock mRunWakeLock;
+        boolean mServiceProcessing;
+
+        public CompatWorkEnqueuer(Context context, ComponentName componentName) {
+            super(componentName);
+            this.mContext = context.getApplicationContext();
+            PowerManager powerManager = (PowerManager) context.getSystemService("power");
+            PowerManager.WakeLock newWakeLock = powerManager.newWakeLock(1, componentName.getClassName() + ":launch");
+            this.mLaunchWakeLock = newWakeLock;
+            newWakeLock.setReferenceCounted(false);
+            PowerManager.WakeLock newWakeLock2 = powerManager.newWakeLock(1, componentName.getClassName() + ":run");
+            this.mRunWakeLock = newWakeLock2;
+            newWakeLock2.setReferenceCounted(false);
+        }
+
+        @Override // androidx.core.app.JobIntentService.WorkEnqueuer
+        public void enqueueWork(Intent intent) {
+            Intent intent2 = new Intent(intent);
+            intent2.setComponent(this.mComponentName);
+            if (this.mContext.startService(intent2) != null) {
+                synchronized (this) {
+                    try {
+                        if (!this.mLaunchingService) {
+                            this.mLaunchingService = true;
+                            if (!this.mServiceProcessing) {
+                                this.mLaunchWakeLock.acquire(ChunkedTrackBlacklistUtil.DEFAULT_TRACK_BLACKLIST_MS);
+                            }
+                        }
+                    } finally {
+                    }
+                }
+            }
+        }
+
+        @Override // androidx.core.app.JobIntentService.WorkEnqueuer
+        public void serviceStartReceived() {
+            synchronized (this) {
+                this.mLaunchingService = false;
+            }
+        }
+
+        @Override // androidx.core.app.JobIntentService.WorkEnqueuer
+        public void serviceProcessingStarted() {
+            synchronized (this) {
+                try {
+                    if (!this.mServiceProcessing) {
+                        this.mServiceProcessing = true;
+                        this.mRunWakeLock.acquire(AuthenticationTokenClaims.MAX_TIME_SINCE_TOKEN_ISSUED);
+                        this.mLaunchWakeLock.release();
+                    }
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+
+        @Override // androidx.core.app.JobIntentService.WorkEnqueuer
+        public void serviceProcessingFinished() {
+            synchronized (this) {
+                try {
+                    if (this.mServiceProcessing) {
+                        if (this.mLaunchingService) {
+                            this.mLaunchWakeLock.acquire(ChunkedTrackBlacklistUtil.DEFAULT_TRACK_BLACKLIST_MS);
+                        }
+                        this.mServiceProcessing = false;
+                        this.mRunWakeLock.release();
+                    }
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+    }
+
+    @RequiresApi(26)
+    public static final class JobServiceEngineImpl extends JobServiceEngine implements CompatJobEngine {
+        static final boolean DEBUG = false;
+        static final String TAG = "JobServiceEngineImpl";
+        final Object mLock;
+        JobParameters mParams;
+        final JobIntentService mService;
+
+        public final class WrapperWorkItem implements GenericWorkItem {
+            final JobWorkItem mJobWork;
+
+            public WrapperWorkItem(JobWorkItem jobWorkItem) {
+                this.mJobWork = jobWorkItem;
+            }
+
+            @Override // androidx.core.app.JobIntentService.GenericWorkItem
+            public Intent getIntent() {
+                return this.mJobWork.getIntent();
+            }
+
+            @Override // androidx.core.app.JobIntentService.GenericWorkItem
+            public void complete() {
+                synchronized (JobServiceEngineImpl.this.mLock) {
+                    try {
+                        JobParameters jobParameters = JobServiceEngineImpl.this.mParams;
+                        if (jobParameters != null) {
+                            jobParameters.completeWork(this.mJobWork);
+                        }
+                    } catch (Throwable th) {
+                        throw th;
+                    }
+                }
+            }
+        }
+
+        public JobServiceEngineImpl(JobIntentService jobIntentService) {
+            super(jobIntentService);
+            this.mLock = new Object();
+            this.mService = jobIntentService;
+        }
+
+        @Override // androidx.core.app.JobIntentService.CompatJobEngine
+        public IBinder compatGetBinder() {
+            return getBinder();
+        }
+
+        @Override // android.app.job.JobServiceEngine
+        public boolean onStartJob(JobParameters jobParameters) {
+            this.mParams = jobParameters;
+            this.mService.ensureProcessorRunningLocked(false);
+            return true;
+        }
+
+        @Override // android.app.job.JobServiceEngine
+        public boolean onStopJob(JobParameters jobParameters) {
+            boolean doStopCurrentWork = this.mService.doStopCurrentWork();
+            synchronized (this.mLock) {
+                this.mParams = null;
+            }
+            return doStopCurrentWork;
+        }
+
+        @Override // androidx.core.app.JobIntentService.CompatJobEngine
+        public GenericWorkItem dequeueWork() {
+            synchronized (this.mLock) {
+                try {
+                    JobParameters jobParameters = this.mParams;
+                    if (jobParameters == null) {
+                        return null;
+                    }
+                    JobWorkItem dequeueWork = jobParameters.dequeueWork();
+                    if (dequeueWork == null) {
+                        return null;
+                    }
+                    dequeueWork.getIntent().setExtrasClassLoader(this.mService.getClassLoader());
+                    return new WrapperWorkItem(dequeueWork);
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+    }
+
+    @RequiresApi(26)
+    public static final class JobWorkEnqueuer extends WorkEnqueuer {
+        private final JobInfo mJobInfo;
+        private final JobScheduler mJobScheduler;
+
+        public JobWorkEnqueuer(Context context, ComponentName componentName, int i) {
+            super(componentName);
+            ensureJobId(i);
+            this.mJobInfo = new JobInfo.Builder(i, this.mComponentName).setOverrideDeadline(0L).build();
+            this.mJobScheduler = (JobScheduler) context.getApplicationContext().getSystemService("jobscheduler");
+        }
+
+        @Override // androidx.core.app.JobIntentService.WorkEnqueuer
+        public void enqueueWork(Intent intent) {
+            this.mJobScheduler.enqueue(this.mJobInfo, new JobWorkItem(intent));
+        }
+    }
+
+    public final class CompatWorkItem implements GenericWorkItem {
+        final Intent mIntent;
+        final int mStartId;
+
+        @Override // androidx.core.app.JobIntentService.GenericWorkItem
+        public Intent getIntent() {
+            return this.mIntent;
+        }
+
+        public CompatWorkItem(Intent intent, int i) {
+            this.mIntent = intent;
+            this.mStartId = i;
+        }
+
+        @Override // androidx.core.app.JobIntentService.GenericWorkItem
+        public void complete() {
+            JobIntentService.this.stopSelf(this.mStartId);
+        }
+    }
+
+    public final class CommandProcessor extends AsyncTask<Void, Void, Void> {
+        public CommandProcessor() {
+        }
+
+        @Override // android.os.AsyncTask
+        public Void doInBackground(Void... voidArr) {
+            while (true) {
+                GenericWorkItem dequeueWork = JobIntentService.this.dequeueWork();
+                if (dequeueWork == null) {
+                    return null;
+                }
+                JobIntentService.this.onHandleWork(dequeueWork.getIntent());
+                dequeueWork.complete();
+            }
+        }
+
+        @Override // android.os.AsyncTask
+        public void onCancelled(Void r1) {
+            JobIntentService.this.processorFinished();
+        }
+
+        @Override // android.os.AsyncTask
+        public void onPostExecute(Void r1) {
+            JobIntentService.this.processorFinished();
+        }
+    }
+
+    @Override // android.app.Service
+    public void onCreate() {
+        super.onCreate();
+        this.mJobImpl = new JobServiceEngineImpl(this);
+        this.mCompatWorkEnqueuer = null;
+    }
+
+    @Override // android.app.Service
+    public int onStartCommand(@Nullable Intent intent, int i, int i2) {
+        if (this.mCompatQueue == null) {
+            return 2;
+        }
+        this.mCompatWorkEnqueuer.serviceStartReceived();
+        synchronized (this.mCompatQueue) {
+            ArrayList<CompatWorkItem> arrayList = this.mCompatQueue;
+            if (intent == null) {
+                intent = new Intent();
+            }
+            arrayList.add(new CompatWorkItem(intent, i2));
+            ensureProcessorRunningLocked(true);
+        }
+        return 3;
+    }
+
+    @Override // android.app.Service
+    public IBinder onBind(@NonNull Intent intent) {
+        CompatJobEngine compatJobEngine = this.mJobImpl;
+        if (compatJobEngine != null) {
+            return compatJobEngine.compatGetBinder();
+        }
+        return null;
+    }
+
+    @Override // android.app.Service
+    public void onDestroy() {
+        super.onDestroy();
+        ArrayList<CompatWorkItem> arrayList = this.mCompatQueue;
+        if (arrayList != null) {
+            synchronized (arrayList) {
+                this.mDestroyed = true;
+                this.mCompatWorkEnqueuer.serviceProcessingFinished();
+            }
+        }
+    }
+
+    public static void enqueueWork(@NonNull Context context, @NonNull Class<?> cls, int i, @NonNull Intent intent) {
+        enqueueWork(context, new ComponentName(context, cls), i, intent);
+    }
+
+    public static void enqueueWork(@NonNull Context context, @NonNull ComponentName componentName, int i, @NonNull Intent intent) {
+        if (intent == null) {
+            throw new IllegalArgumentException("work must not be null");
+        }
+        synchronized (sLock) {
+            WorkEnqueuer workEnqueuer = getWorkEnqueuer(context, componentName, true, i);
+            workEnqueuer.ensureJobId(i);
+            workEnqueuer.enqueueWork(intent);
+        }
+    }
+
+    public static WorkEnqueuer getWorkEnqueuer(Context context, ComponentName componentName, boolean z, int i) {
+        HashMap<ComponentName, WorkEnqueuer> hashMap = sClassWorkEnqueuer;
+        WorkEnqueuer workEnqueuer = hashMap.get(componentName);
+        if (workEnqueuer != null) {
+            return workEnqueuer;
+        }
+        if (!z) {
+            throw new IllegalArgumentException("Can't be here without a job id");
+        }
+        JobWorkEnqueuer jobWorkEnqueuer = new JobWorkEnqueuer(context, componentName, i);
+        hashMap.put(componentName, jobWorkEnqueuer);
+        return jobWorkEnqueuer;
+    }
+
+    public boolean doStopCurrentWork() {
+        CommandProcessor commandProcessor = this.mCurProcessor;
+        if (commandProcessor != null) {
+            commandProcessor.cancel(this.mInterruptIfStopped);
+        }
+        this.mStopped = true;
+        return onStopCurrentWork();
+    }
+
+    public void ensureProcessorRunningLocked(boolean z) {
+        if (this.mCurProcessor == null) {
+            this.mCurProcessor = new CommandProcessor();
+            WorkEnqueuer workEnqueuer = this.mCompatWorkEnqueuer;
+            if (workEnqueuer != null && z) {
+                workEnqueuer.serviceProcessingStarted();
+            }
+            this.mCurProcessor.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, new Void[0]);
+        }
+    }
+
+    public void processorFinished() {
+        ArrayList<CompatWorkItem> arrayList = this.mCompatQueue;
+        if (arrayList != null) {
+            synchronized (arrayList) {
+                try {
+                    this.mCurProcessor = null;
+                    ArrayList<CompatWorkItem> arrayList2 = this.mCompatQueue;
+                    if (arrayList2 != null && arrayList2.size() > 0) {
+                        ensureProcessorRunningLocked(false);
+                    } else if (!this.mDestroyed) {
+                        this.mCompatWorkEnqueuer.serviceProcessingFinished();
+                    }
+                } finally {
+                }
+            }
+        }
+    }
+
+    public GenericWorkItem dequeueWork() {
+        CompatJobEngine compatJobEngine = this.mJobImpl;
+        if (compatJobEngine != null) {
+            return compatJobEngine.dequeueWork();
+        }
+        synchronized (this.mCompatQueue) {
+            try {
+                if (this.mCompatQueue.size() <= 0) {
+                    return null;
+                }
+                return this.mCompatQueue.remove(0);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+}

decompiled/sources/androidx/core/app/LocaleManagerCompat.java

@@ -0,0 +1,88 @@
+package androidx.core.app;
+
+import android.app.LocaleManager;
+import android.content.Context;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.os.Build;
+import android.os.LocaleList;
+import androidx.annotation.AnyThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.VisibleForTesting;
+import androidx.core.os.LocaleListCompat;
+import java.util.Locale;
+
+/* loaded from: classes.dex */
+public final class LocaleManagerCompat {
+    private LocaleManagerCompat() {
+    }
+
+    @NonNull
+    @AnyThread
+    public static LocaleListCompat getSystemLocales(@NonNull Context context) {
+        LocaleListCompat emptyLocaleList = LocaleListCompat.getEmptyLocaleList();
+        if (Build.VERSION.SDK_INT >= 33) {
+            Object localeManagerForApplication = getLocaleManagerForApplication(context);
+            return localeManagerForApplication != null ? LocaleListCompat.wrap(Api33Impl.localeManagerGetSystemLocales(localeManagerForApplication)) : emptyLocaleList;
+        }
+        return getConfigurationLocales(Resources.getSystem().getConfiguration());
+    }
+
+    @NonNull
+    @AnyThread
+    public static LocaleListCompat getApplicationLocales(@NonNull Context context) {
+        if (Build.VERSION.SDK_INT >= 33) {
+            Object localeManagerForApplication = getLocaleManagerForApplication(context);
+            if (localeManagerForApplication != null) {
+                return LocaleListCompat.wrap(Api33Impl.localeManagerGetApplicationLocales(localeManagerForApplication));
+            }
+            return LocaleListCompat.getEmptyLocaleList();
+        }
+        return LocaleListCompat.forLanguageTags(AppLocalesStorageHelper.readLocales(context));
+    }
+
+    @RequiresApi(33)
+    private static Object getLocaleManagerForApplication(Context context) {
+        return context.getSystemService("locale");
+    }
+
+    @VisibleForTesting
+    public static LocaleListCompat getConfigurationLocales(Configuration configuration) {
+        return Api24Impl.getLocales(configuration);
+    }
+
+    @RequiresApi(21)
+    public static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        public static String toLanguageTag(Locale locale) {
+            return locale.toLanguageTag();
+        }
+    }
+
+    @RequiresApi(24)
+    public static class Api24Impl {
+        private Api24Impl() {
+        }
+
+        public static LocaleListCompat getLocales(Configuration configuration) {
+            return LocaleListCompat.forLanguageTags(configuration.getLocales().toLanguageTags());
+        }
+    }
+
+    @RequiresApi(33)
+    public static class Api33Impl {
+        private Api33Impl() {
+        }
+
+        public static LocaleList localeManagerGetSystemLocales(Object obj) {
+            return ((LocaleManager) obj).getSystemLocales();
+        }
+
+        public static LocaleList localeManagerGetApplicationLocales(Object obj) {
+            return ((LocaleManager) obj).getApplicationLocales();
+        }
+    }
+}

decompiled/sources/androidx/core/app/MultiWindowModeChangedInfo.java

@@ -0,0 +1,38 @@
+package androidx.core.app;
+
+import android.content.res.Configuration;
+import androidx.annotation.RequiresApi;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class MultiWindowModeChangedInfo {
+    private final boolean isInMultiWindowMode;
+
+    @RequiresApi(26)
+    private Configuration newConfiguration;
+
+    public final boolean isInMultiWindowMode() {
+        return this.isInMultiWindowMode;
+    }
+
+    public MultiWindowModeChangedInfo(boolean z) {
+        this.isInMultiWindowMode = z;
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    @RequiresApi(26)
+    public MultiWindowModeChangedInfo(boolean z, Configuration newConfig) {
+        this(z);
+        Intrinsics.checkNotNullParameter(newConfig, "newConfig");
+        this.newConfiguration = newConfig;
+    }
+
+    @RequiresApi(26)
+    public final Configuration getNewConfig() {
+        Configuration configuration = this.newConfiguration;
+        if (configuration != null) {
+            return configuration;
+        }
+        throw new IllegalStateException("MultiWindowModeChangedInfo must be constructed with the constructor that takes a Configuration to access the newConfig. Are you running on an API 26 or higher device that makes this information available?".toString());
+    }
+}

decompiled/sources/androidx/core/app/NavUtils.java

@@ -0,0 +1,118 @@
+package androidx.core.app;
+
+import android.app.Activity;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.Bundle;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.ReplaceWith;
+
+/* loaded from: classes.dex */
+public final class NavUtils {
+    public static final String PARENT_ACTIVITY = "android.support.PARENT_ACTIVITY";
+    private static final String TAG = "NavUtils";
+
+    @ReplaceWith(expression = "sourceActivity.shouldUpRecreateTask(targetIntent)")
+    @Deprecated
+    public static boolean shouldUpRecreateTask(@NonNull Activity activity, @NonNull Intent intent) {
+        return activity.shouldUpRecreateTask(intent);
+    }
+
+    public static void navigateUpFromSameTask(@NonNull Activity activity) {
+        Intent parentActivityIntent = getParentActivityIntent(activity);
+        if (parentActivityIntent == null) {
+            throw new IllegalArgumentException("Activity " + activity.getClass().getSimpleName() + " does not have a parent activity name specified. (Did you forget to add the android.support.PARENT_ACTIVITY <meta-data>  element in your manifest?)");
+        }
+        navigateUpTo(activity, parentActivityIntent);
+    }
+
+    @ReplaceWith(expression = "sourceActivity.navigateUpTo(upIntent)")
+    @Deprecated
+    public static void navigateUpTo(@NonNull Activity activity, @NonNull Intent intent) {
+        activity.navigateUpTo(intent);
+    }
+
+    @Nullable
+    public static Intent getParentActivityIntent(@NonNull Activity activity) {
+        Intent parentActivityIntent = activity.getParentActivityIntent();
+        if (parentActivityIntent != null) {
+            return parentActivityIntent;
+        }
+        String parentActivityName = getParentActivityName(activity);
+        if (parentActivityName == null) {
+            return null;
+        }
+        ComponentName componentName = new ComponentName(activity, parentActivityName);
+        try {
+            if (getParentActivityName(activity, componentName) == null) {
+                return Intent.makeMainActivity(componentName);
+            }
+            return new Intent().setComponent(componentName);
+        } catch (PackageManager.NameNotFoundException unused) {
+            Log.e(TAG, "getParentActivityIntent: bad parentActivityName '" + parentActivityName + "' in manifest");
+            return null;
+        }
+    }
+
+    @Nullable
+    public static Intent getParentActivityIntent(@NonNull Context context, @NonNull Class<?> cls) throws PackageManager.NameNotFoundException {
+        String parentActivityName = getParentActivityName(context, new ComponentName(context, cls));
+        if (parentActivityName == null) {
+            return null;
+        }
+        ComponentName componentName = new ComponentName(context, parentActivityName);
+        if (getParentActivityName(context, componentName) == null) {
+            return Intent.makeMainActivity(componentName);
+        }
+        return new Intent().setComponent(componentName);
+    }
+
+    @Nullable
+    public static Intent getParentActivityIntent(@NonNull Context context, @NonNull ComponentName componentName) throws PackageManager.NameNotFoundException {
+        String parentActivityName = getParentActivityName(context, componentName);
+        if (parentActivityName == null) {
+            return null;
+        }
+        ComponentName componentName2 = new ComponentName(componentName.getPackageName(), parentActivityName);
+        if (getParentActivityName(context, componentName2) == null) {
+            return Intent.makeMainActivity(componentName2);
+        }
+        return new Intent().setComponent(componentName2);
+    }
+
+    @Nullable
+    public static String getParentActivityName(@NonNull Activity activity) {
+        try {
+            return getParentActivityName(activity, activity.getComponentName());
+        } catch (PackageManager.NameNotFoundException e) {
+            throw new IllegalArgumentException(e);
+        }
+    }
+
+    @Nullable
+    public static String getParentActivityName(@NonNull Context context, @NonNull ComponentName componentName) throws PackageManager.NameNotFoundException {
+        String string;
+        ActivityInfo activityInfo = context.getPackageManager().getActivityInfo(componentName, Build.VERSION.SDK_INT >= 29 ? 269222528 : 787072);
+        String str = activityInfo.parentActivityName;
+        if (str != null) {
+            return str;
+        }
+        Bundle bundle = activityInfo.metaData;
+        if (bundle == null || (string = bundle.getString(PARENT_ACTIVITY)) == null) {
+            return null;
+        }
+        if (string.charAt(0) != '.') {
+            return string;
+        }
+        return context.getPackageName() + string;
+    }
+
+    private NavUtils() {
+    }
+}

decompiled/sources/androidx/core/app/NotificationBuilderWithBuilderAccessor.java

@@ -0,0 +1,10 @@
+package androidx.core.app;
+
+import android.app.Notification;
+import androidx.annotation.RestrictTo;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public interface NotificationBuilderWithBuilderAccessor {
+    Notification.Builder getBuilder();
+}

decompiled/sources/androidx/core/app/NotificationChannelCompat.java

@@ -0,0 +1,398 @@
+package androidx.core.app;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.media.AudioAttributes;
+import android.net.Uri;
+import android.os.Build;
+import android.provider.Settings;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.util.Preconditions;
+
+/* loaded from: classes.dex */
+public class NotificationChannelCompat {
+    public static final String DEFAULT_CHANNEL_ID = "miscellaneous";
+    private static final int DEFAULT_LIGHT_COLOR = 0;
+    private static final boolean DEFAULT_SHOW_BADGE = true;
+    AudioAttributes mAudioAttributes;
+    private boolean mBypassDnd;
+    private boolean mCanBubble;
+    String mConversationId;
+    String mDescription;
+    String mGroupId;
+
+    @NonNull
+    final String mId;
+    int mImportance;
+    private boolean mImportantConversation;
+    int mLightColor;
+    boolean mLights;
+    private int mLockscreenVisibility;
+    CharSequence mName;
+    String mParentId;
+    boolean mShowBadge;
+    Uri mSound;
+    boolean mVibrationEnabled;
+    long[] mVibrationPattern;
+
+    public boolean canBubble() {
+        return this.mCanBubble;
+    }
+
+    public boolean canBypassDnd() {
+        return this.mBypassDnd;
+    }
+
+    public boolean canShowBadge() {
+        return this.mShowBadge;
+    }
+
+    @Nullable
+    public AudioAttributes getAudioAttributes() {
+        return this.mAudioAttributes;
+    }
+
+    @Nullable
+    public String getConversationId() {
+        return this.mConversationId;
+    }
+
+    @Nullable
+    public String getDescription() {
+        return this.mDescription;
+    }
+
+    @Nullable
+    public String getGroup() {
+        return this.mGroupId;
+    }
+
+    @NonNull
+    public String getId() {
+        return this.mId;
+    }
+
+    public int getImportance() {
+        return this.mImportance;
+    }
+
+    public int getLightColor() {
+        return this.mLightColor;
+    }
+
+    public int getLockscreenVisibility() {
+        return this.mLockscreenVisibility;
+    }
+
+    @Nullable
+    public CharSequence getName() {
+        return this.mName;
+    }
+
+    @Nullable
+    public String getParentChannelId() {
+        return this.mParentId;
+    }
+
+    @Nullable
+    public Uri getSound() {
+        return this.mSound;
+    }
+
+    @Nullable
+    public long[] getVibrationPattern() {
+        return this.mVibrationPattern;
+    }
+
+    public boolean isImportantConversation() {
+        return this.mImportantConversation;
+    }
+
+    public boolean shouldShowLights() {
+        return this.mLights;
+    }
+
+    public boolean shouldVibrate() {
+        return this.mVibrationEnabled;
+    }
+
+    public static class Builder {
+        private final NotificationChannelCompat mChannel;
+
+        @NonNull
+        public NotificationChannelCompat build() {
+            return this.mChannel;
+        }
+
+        public Builder(@NonNull String str, int i) {
+            this.mChannel = new NotificationChannelCompat(str, i);
+        }
+
+        @NonNull
+        public Builder setName(@Nullable CharSequence charSequence) {
+            this.mChannel.mName = charSequence;
+            return this;
+        }
+
+        @NonNull
+        public Builder setImportance(int i) {
+            this.mChannel.mImportance = i;
+            return this;
+        }
+
+        @NonNull
+        public Builder setDescription(@Nullable String str) {
+            this.mChannel.mDescription = str;
+            return this;
+        }
+
+        @NonNull
+        public Builder setGroup(@Nullable String str) {
+            this.mChannel.mGroupId = str;
+            return this;
+        }
+
+        @NonNull
+        public Builder setShowBadge(boolean z) {
+            this.mChannel.mShowBadge = z;
+            return this;
+        }
+
+        @NonNull
+        public Builder setSound(@Nullable Uri uri, @Nullable AudioAttributes audioAttributes) {
+            NotificationChannelCompat notificationChannelCompat = this.mChannel;
+            notificationChannelCompat.mSound = uri;
+            notificationChannelCompat.mAudioAttributes = audioAttributes;
+            return this;
+        }
+
+        @NonNull
+        public Builder setLightsEnabled(boolean z) {
+            this.mChannel.mLights = z;
+            return this;
+        }
+
+        @NonNull
+        public Builder setLightColor(int i) {
+            this.mChannel.mLightColor = i;
+            return this;
+        }
+
+        @NonNull
+        public Builder setVibrationEnabled(boolean z) {
+            this.mChannel.mVibrationEnabled = z;
+            return this;
+        }
+
+        @NonNull
+        public Builder setVibrationPattern(@Nullable long[] jArr) {
+            NotificationChannelCompat notificationChannelCompat = this.mChannel;
+            notificationChannelCompat.mVibrationEnabled = jArr != null && jArr.length > 0;
+            notificationChannelCompat.mVibrationPattern = jArr;
+            return this;
+        }
+
+        @NonNull
+        public Builder setConversationId(@NonNull String str, @NonNull String str2) {
+            if (Build.VERSION.SDK_INT >= 30) {
+                NotificationChannelCompat notificationChannelCompat = this.mChannel;
+                notificationChannelCompat.mParentId = str;
+                notificationChannelCompat.mConversationId = str2;
+            }
+            return this;
+        }
+    }
+
+    public NotificationChannelCompat(@NonNull String str, int i) {
+        this.mShowBadge = true;
+        this.mSound = Settings.System.DEFAULT_NOTIFICATION_URI;
+        this.mLightColor = 0;
+        this.mId = (String) Preconditions.checkNotNull(str);
+        this.mImportance = i;
+        this.mAudioAttributes = Notification.AUDIO_ATTRIBUTES_DEFAULT;
+    }
+
+    @RequiresApi(26)
+    public NotificationChannelCompat(@NonNull NotificationChannel notificationChannel) {
+        this(Api26Impl.getId(notificationChannel), Api26Impl.getImportance(notificationChannel));
+        this.mName = Api26Impl.getName(notificationChannel);
+        this.mDescription = Api26Impl.getDescription(notificationChannel);
+        this.mGroupId = Api26Impl.getGroup(notificationChannel);
+        this.mShowBadge = Api26Impl.canShowBadge(notificationChannel);
+        this.mSound = Api26Impl.getSound(notificationChannel);
+        this.mAudioAttributes = Api26Impl.getAudioAttributes(notificationChannel);
+        this.mLights = Api26Impl.shouldShowLights(notificationChannel);
+        this.mLightColor = Api26Impl.getLightColor(notificationChannel);
+        this.mVibrationEnabled = Api26Impl.shouldVibrate(notificationChannel);
+        this.mVibrationPattern = Api26Impl.getVibrationPattern(notificationChannel);
+        int i = Build.VERSION.SDK_INT;
+        if (i >= 30) {
+            this.mParentId = Api30Impl.getParentChannelId(notificationChannel);
+            this.mConversationId = Api30Impl.getConversationId(notificationChannel);
+        }
+        this.mBypassDnd = Api26Impl.canBypassDnd(notificationChannel);
+        this.mLockscreenVisibility = Api26Impl.getLockscreenVisibility(notificationChannel);
+        if (i >= 29) {
+            this.mCanBubble = Api29Impl.canBubble(notificationChannel);
+        }
+        if (i >= 30) {
+            this.mImportantConversation = Api30Impl.isImportantConversation(notificationChannel);
+        }
+    }
+
+    public NotificationChannel getNotificationChannel() {
+        String str;
+        String str2;
+        int i = Build.VERSION.SDK_INT;
+        NotificationChannel createNotificationChannel = Api26Impl.createNotificationChannel(this.mId, this.mName, this.mImportance);
+        Api26Impl.setDescription(createNotificationChannel, this.mDescription);
+        Api26Impl.setGroup(createNotificationChannel, this.mGroupId);
+        Api26Impl.setShowBadge(createNotificationChannel, this.mShowBadge);
+        Api26Impl.setSound(createNotificationChannel, this.mSound, this.mAudioAttributes);
+        Api26Impl.enableLights(createNotificationChannel, this.mLights);
+        Api26Impl.setLightColor(createNotificationChannel, this.mLightColor);
+        Api26Impl.setVibrationPattern(createNotificationChannel, this.mVibrationPattern);
+        Api26Impl.enableVibration(createNotificationChannel, this.mVibrationEnabled);
+        if (i >= 30 && (str = this.mParentId) != null && (str2 = this.mConversationId) != null) {
+            Api30Impl.setConversationId(createNotificationChannel, str, str2);
+        }
+        return createNotificationChannel;
+    }
+
+    @NonNull
+    public Builder toBuilder() {
+        return new Builder(this.mId, this.mImportance).setName(this.mName).setDescription(this.mDescription).setGroup(this.mGroupId).setShowBadge(this.mShowBadge).setSound(this.mSound, this.mAudioAttributes).setLightsEnabled(this.mLights).setLightColor(this.mLightColor).setVibrationEnabled(this.mVibrationEnabled).setVibrationPattern(this.mVibrationPattern).setConversationId(this.mParentId, this.mConversationId);
+    }
+
+    @RequiresApi(26)
+    public static class Api26Impl {
+        private Api26Impl() {
+        }
+
+        public static NotificationChannel createNotificationChannel(String str, CharSequence charSequence, int i) {
+            return new NotificationChannel(str, charSequence, i);
+        }
+
+        public static String getId(NotificationChannel notificationChannel) {
+            return notificationChannel.getId();
+        }
+
+        public static int getImportance(NotificationChannel notificationChannel) {
+            return notificationChannel.getImportance();
+        }
+
+        public static CharSequence getName(NotificationChannel notificationChannel) {
+            return notificationChannel.getName();
+        }
+
+        public static String getDescription(NotificationChannel notificationChannel) {
+            return notificationChannel.getDescription();
+        }
+
+        public static void setDescription(NotificationChannel notificationChannel, String str) {
+            notificationChannel.setDescription(str);
+        }
+
+        public static String getGroup(NotificationChannel notificationChannel) {
+            return notificationChannel.getGroup();
+        }
+
+        public static void setGroup(NotificationChannel notificationChannel, String str) {
+            notificationChannel.setGroup(str);
+        }
+
+        public static boolean canShowBadge(NotificationChannel notificationChannel) {
+            return notificationChannel.canShowBadge();
+        }
+
+        public static void setShowBadge(NotificationChannel notificationChannel, boolean z) {
+            notificationChannel.setShowBadge(z);
+        }
+
+        public static Uri getSound(NotificationChannel notificationChannel) {
+            return notificationChannel.getSound();
+        }
+
+        public static void setSound(NotificationChannel notificationChannel, Uri uri, AudioAttributes audioAttributes) {
+            notificationChannel.setSound(uri, audioAttributes);
+        }
+
+        public static AudioAttributes getAudioAttributes(NotificationChannel notificationChannel) {
+            return notificationChannel.getAudioAttributes();
+        }
+
+        public static boolean shouldShowLights(NotificationChannel notificationChannel) {
+            return notificationChannel.shouldShowLights();
+        }
+
+        public static void enableLights(NotificationChannel notificationChannel, boolean z) {
+            notificationChannel.enableLights(z);
+        }
+
+        public static int getLightColor(NotificationChannel notificationChannel) {
+            return notificationChannel.getLightColor();
+        }
+
+        public static void setLightColor(NotificationChannel notificationChannel, int i) {
+            notificationChannel.setLightColor(i);
+        }
+
+        public static boolean shouldVibrate(NotificationChannel notificationChannel) {
+            return notificationChannel.shouldVibrate();
+        }
+
+        public static void enableVibration(NotificationChannel notificationChannel, boolean z) {
+            notificationChannel.enableVibration(z);
+        }
+
+        public static long[] getVibrationPattern(NotificationChannel notificationChannel) {
+            return notificationChannel.getVibrationPattern();
+        }
+
+        public static void setVibrationPattern(NotificationChannel notificationChannel, long[] jArr) {
+            notificationChannel.setVibrationPattern(jArr);
+        }
+
+        public static boolean canBypassDnd(NotificationChannel notificationChannel) {
+            return notificationChannel.canBypassDnd();
+        }
+
+        public static int getLockscreenVisibility(NotificationChannel notificationChannel) {
+            return notificationChannel.getLockscreenVisibility();
+        }
+    }
+
+    @RequiresApi(29)
+    public static class Api29Impl {
+        private Api29Impl() {
+        }
+
+        public static boolean canBubble(NotificationChannel notificationChannel) {
+            return notificationChannel.canBubble();
+        }
+    }
+
+    @RequiresApi(30)
+    public static class Api30Impl {
+        private Api30Impl() {
+        }
+
+        public static String getParentChannelId(NotificationChannel notificationChannel) {
+            return notificationChannel.getParentChannelId();
+        }
+
+        public static String getConversationId(NotificationChannel notificationChannel) {
+            return notificationChannel.getConversationId();
+        }
+
+        public static void setConversationId(NotificationChannel notificationChannel, String str, String str2) {
+            notificationChannel.setConversationId(str, str2);
+        }
+
+        public static boolean isImportantConversation(NotificationChannel notificationChannel) {
+            return notificationChannel.isImportantConversation();
+        }
+    }
+}

decompiled/sources/androidx/core/app/NotificationChannelGroupCompat.java

@@ -0,0 +1,165 @@
+package androidx.core.app;
+
+import android.app.NotificationChannel;
+import android.app.NotificationChannelGroup;
+import android.os.Build;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.util.Preconditions;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public class NotificationChannelGroupCompat {
+    private boolean mBlocked;
+    private List<NotificationChannelCompat> mChannels;
+    String mDescription;
+    final String mId;
+    CharSequence mName;
+
+    @NonNull
+    public List<NotificationChannelCompat> getChannels() {
+        return this.mChannels;
+    }
+
+    @Nullable
+    public String getDescription() {
+        return this.mDescription;
+    }
+
+    @NonNull
+    public String getId() {
+        return this.mId;
+    }
+
+    @Nullable
+    public CharSequence getName() {
+        return this.mName;
+    }
+
+    public boolean isBlocked() {
+        return this.mBlocked;
+    }
+
+    public static class Builder {
+        final NotificationChannelGroupCompat mGroup;
+
+        @NonNull
+        public NotificationChannelGroupCompat build() {
+            return this.mGroup;
+        }
+
+        public Builder(@NonNull String str) {
+            this.mGroup = new NotificationChannelGroupCompat(str);
+        }
+
+        @NonNull
+        public Builder setName(@Nullable CharSequence charSequence) {
+            this.mGroup.mName = charSequence;
+            return this;
+        }
+
+        @NonNull
+        public Builder setDescription(@Nullable String str) {
+            this.mGroup.mDescription = str;
+            return this;
+        }
+    }
+
+    public NotificationChannelGroupCompat(@NonNull String str) {
+        this.mChannels = Collections.emptyList();
+        this.mId = (String) Preconditions.checkNotNull(str);
+    }
+
+    @RequiresApi(28)
+    public NotificationChannelGroupCompat(@NonNull NotificationChannelGroup notificationChannelGroup) {
+        this(notificationChannelGroup, Collections.emptyList());
+    }
+
+    @RequiresApi(26)
+    public NotificationChannelGroupCompat(@NonNull NotificationChannelGroup notificationChannelGroup, @NonNull List<NotificationChannel> list) {
+        this(Api26Impl.getId(notificationChannelGroup));
+        this.mName = Api26Impl.getName(notificationChannelGroup);
+        int i = Build.VERSION.SDK_INT;
+        if (i >= 28) {
+            this.mDescription = Api28Impl.getDescription(notificationChannelGroup);
+        }
+        if (i >= 28) {
+            this.mBlocked = Api28Impl.isBlocked(notificationChannelGroup);
+            this.mChannels = getChannelsCompat(Api26Impl.getChannels(notificationChannelGroup));
+        } else {
+            this.mChannels = getChannelsCompat(list);
+        }
+    }
+
+    @RequiresApi(26)
+    private List<NotificationChannelCompat> getChannelsCompat(List<NotificationChannel> list) {
+        ArrayList arrayList = new ArrayList();
+        for (NotificationChannel notificationChannel : list) {
+            if (this.mId.equals(Api26Impl.getGroup(notificationChannel))) {
+                arrayList.add(new NotificationChannelCompat(notificationChannel));
+            }
+        }
+        return arrayList;
+    }
+
+    public NotificationChannelGroup getNotificationChannelGroup() {
+        int i = Build.VERSION.SDK_INT;
+        NotificationChannelGroup createNotificationChannelGroup = Api26Impl.createNotificationChannelGroup(this.mId, this.mName);
+        if (i >= 28) {
+            Api28Impl.setDescription(createNotificationChannelGroup, this.mDescription);
+        }
+        return createNotificationChannelGroup;
+    }
+
+    @NonNull
+    public Builder toBuilder() {
+        return new Builder(this.mId).setName(this.mName).setDescription(this.mDescription);
+    }
+
+    @RequiresApi(26)
+    public static class Api26Impl {
+        private Api26Impl() {
+        }
+
+        public static NotificationChannelGroup createNotificationChannelGroup(String str, CharSequence charSequence) {
+            return new NotificationChannelGroup(str, charSequence);
+        }
+
+        public static String getId(NotificationChannelGroup notificationChannelGroup) {
+            return notificationChannelGroup.getId();
+        }
+
+        public static CharSequence getName(NotificationChannelGroup notificationChannelGroup) {
+            return notificationChannelGroup.getName();
+        }
+
+        public static List<NotificationChannel> getChannels(NotificationChannelGroup notificationChannelGroup) {
+            return notificationChannelGroup.getChannels();
+        }
+
+        public static String getGroup(NotificationChannel notificationChannel) {
+            return notificationChannel.getGroup();
+        }
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static boolean isBlocked(NotificationChannelGroup notificationChannelGroup) {
+            return notificationChannelGroup.isBlocked();
+        }
+
+        public static String getDescription(NotificationChannelGroup notificationChannelGroup) {
+            return notificationChannelGroup.getDescription();
+        }
+
+        public static void setDescription(NotificationChannelGroup notificationChannelGroup, String str) {
+            notificationChannelGroup.setDescription(str);
+        }
+    }
+}

decompiled/sources/androidx/core/app/NotificationCompat$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,8 @@
+package androidx.core.app;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class NotificationCompat$$ExternalSyntheticApiModelOutline0 {
+    public static /* bridge */ /* synthetic */ android.app.Person m(Object obj) {
+        return (android.app.Person) obj;
+    }
+}

decompiled/sources/androidx/core/app/NotificationCompat$CallStyle$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.core.app;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class NotificationCompat$CallStyle$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/core/app/NotificationCompatBuilder.java

@@ -0,0 +1,483 @@
+package androidx.core.app;
+
+import android.app.Notification;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.LocusId;
+import android.graphics.drawable.Icon;
+import android.media.AudioAttributes;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.widget.RemoteViews;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.collection.ArraySet;
+import androidx.core.app.NotificationCompat;
+import androidx.core.content.LocusIdCompat;
+import androidx.core.graphics.drawable.IconCompat;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+class NotificationCompatBuilder implements NotificationBuilderWithBuilderAccessor {
+    private RemoteViews mBigContentView;
+    private final Notification.Builder mBuilder;
+    private final NotificationCompat.Builder mBuilderCompat;
+    private RemoteViews mContentView;
+    private final Context mContext;
+    private int mGroupAlertBehavior;
+    private RemoteViews mHeadsUpContentView;
+    private final List<Bundle> mActionExtrasList = new ArrayList();
+    private final Bundle mExtras = new Bundle();
+
+    @Override // androidx.core.app.NotificationBuilderWithBuilderAccessor
+    public Notification.Builder getBuilder() {
+        return this.mBuilder;
+    }
+
+    public Context getContext() {
+        return this.mContext;
+    }
+
+    public NotificationCompatBuilder(NotificationCompat.Builder builder) {
+        List list;
+        int i;
+        this.mBuilderCompat = builder;
+        Context context = builder.mContext;
+        this.mContext = context;
+        Notification.Builder createBuilder = Api26Impl.createBuilder(context, builder.mChannelId);
+        this.mBuilder = createBuilder;
+        Notification notification = builder.mNotification;
+        createBuilder.setWhen(notification.when).setSmallIcon(notification.icon, notification.iconLevel).setContent(notification.contentView).setTicker(notification.tickerText, builder.mTickerView).setVibrate(notification.vibrate).setLights(notification.ledARGB, notification.ledOnMS, notification.ledOffMS).setOngoing((notification.flags & 2) != 0).setOnlyAlertOnce((notification.flags & 8) != 0).setAutoCancel((notification.flags & 16) != 0).setDefaults(notification.defaults).setContentTitle(builder.mContentTitle).setContentText(builder.mContentText).setContentInfo(builder.mContentInfo).setContentIntent(builder.mContentIntent).setDeleteIntent(notification.deleteIntent).setFullScreenIntent(builder.mFullScreenIntent, (notification.flags & 128) != 0).setNumber(builder.mNumber).setProgress(builder.mProgressMax, builder.mProgress, builder.mProgressIndeterminate);
+        IconCompat iconCompat = builder.mLargeIcon;
+        Api23Impl.setLargeIcon(createBuilder, iconCompat == null ? null : iconCompat.toIcon(context));
+        createBuilder.setSubText(builder.mSubText).setUsesChronometer(builder.mUseChronometer).setPriority(builder.mPriority);
+        NotificationCompat.Style style = builder.mStyle;
+        if (style instanceof NotificationCompat.CallStyle) {
+            Iterator<NotificationCompat.Action> it = ((NotificationCompat.CallStyle) style).getActionsListWithSystemActions().iterator();
+            while (it.hasNext()) {
+                addAction(it.next());
+            }
+        } else {
+            Iterator<NotificationCompat.Action> it2 = builder.mActions.iterator();
+            while (it2.hasNext()) {
+                addAction(it2.next());
+            }
+        }
+        Bundle bundle = builder.mExtras;
+        if (bundle != null) {
+            this.mExtras.putAll(bundle);
+        }
+        int i2 = Build.VERSION.SDK_INT;
+        this.mContentView = builder.mContentView;
+        this.mBigContentView = builder.mBigContentView;
+        this.mBuilder.setShowWhen(builder.mShowWhen);
+        Api20Impl.setLocalOnly(this.mBuilder, builder.mLocalOnly);
+        Api20Impl.setGroup(this.mBuilder, builder.mGroupKey);
+        Api20Impl.setSortKey(this.mBuilder, builder.mSortKey);
+        Api20Impl.setGroupSummary(this.mBuilder, builder.mGroupSummary);
+        this.mGroupAlertBehavior = builder.mGroupAlertBehavior;
+        Api21Impl.setCategory(this.mBuilder, builder.mCategory);
+        Api21Impl.setColor(this.mBuilder, builder.mColor);
+        Api21Impl.setVisibility(this.mBuilder, builder.mVisibility);
+        Api21Impl.setPublicVersion(this.mBuilder, builder.mPublicVersion);
+        Api21Impl.setSound(this.mBuilder, notification.sound, notification.audioAttributes);
+        if (i2 < 28) {
+            list = combineLists(getPeople(builder.mPersonList), builder.mPeople);
+        } else {
+            list = builder.mPeople;
+        }
+        if (list != null && !list.isEmpty()) {
+            Iterator it3 = list.iterator();
+            while (it3.hasNext()) {
+                Api21Impl.addPerson(this.mBuilder, (String) it3.next());
+            }
+        }
+        this.mHeadsUpContentView = builder.mHeadsUpContentView;
+        if (builder.mInvisibleActions.size() > 0) {
+            Bundle bundle2 = builder.getExtras().getBundle("android.car.EXTENSIONS");
+            bundle2 = bundle2 == null ? new Bundle() : bundle2;
+            Bundle bundle3 = new Bundle(bundle2);
+            Bundle bundle4 = new Bundle();
+            for (int i3 = 0; i3 < builder.mInvisibleActions.size(); i3++) {
+                bundle4.putBundle(Integer.toString(i3), NotificationCompatJellybean.getBundleForAction(builder.mInvisibleActions.get(i3)));
+            }
+            bundle2.putBundle("invisible_actions", bundle4);
+            bundle3.putBundle("invisible_actions", bundle4);
+            builder.getExtras().putBundle("android.car.EXTENSIONS", bundle2);
+            this.mExtras.putBundle("android.car.EXTENSIONS", bundle3);
+        }
+        int i4 = Build.VERSION.SDK_INT;
+        Object obj = builder.mSmallIcon;
+        if (obj != null) {
+            Api23Impl.setSmallIcon(this.mBuilder, obj);
+        }
+        this.mBuilder.setExtras(builder.mExtras);
+        Api24Impl.setRemoteInputHistory(this.mBuilder, builder.mRemoteInputHistory);
+        RemoteViews remoteViews = builder.mContentView;
+        if (remoteViews != null) {
+            Api24Impl.setCustomContentView(this.mBuilder, remoteViews);
+        }
+        RemoteViews remoteViews2 = builder.mBigContentView;
+        if (remoteViews2 != null) {
+            Api24Impl.setCustomBigContentView(this.mBuilder, remoteViews2);
+        }
+        RemoteViews remoteViews3 = builder.mHeadsUpContentView;
+        if (remoteViews3 != null) {
+            Api24Impl.setCustomHeadsUpContentView(this.mBuilder, remoteViews3);
+        }
+        Api26Impl.setBadgeIconType(this.mBuilder, builder.mBadgeIcon);
+        Api26Impl.setSettingsText(this.mBuilder, builder.mSettingsText);
+        Api26Impl.setShortcutId(this.mBuilder, builder.mShortcutId);
+        Api26Impl.setTimeoutAfter(this.mBuilder, builder.mTimeout);
+        Api26Impl.setGroupAlertBehavior(this.mBuilder, builder.mGroupAlertBehavior);
+        if (builder.mColorizedSet) {
+            Api26Impl.setColorized(this.mBuilder, builder.mColorized);
+        }
+        if (!TextUtils.isEmpty(builder.mChannelId)) {
+            this.mBuilder.setSound(null).setDefaults(0).setLights(0, 0, 0).setVibrate(null);
+        }
+        if (i4 >= 28) {
+            Iterator<Person> it4 = builder.mPersonList.iterator();
+            while (it4.hasNext()) {
+                Api28Impl.addPerson(this.mBuilder, it4.next().toAndroidPerson());
+            }
+        }
+        int i5 = Build.VERSION.SDK_INT;
+        if (i5 >= 29) {
+            Api29Impl.setAllowSystemGeneratedContextualActions(this.mBuilder, builder.mAllowSystemGeneratedContextualActions);
+            Api29Impl.setBubbleMetadata(this.mBuilder, NotificationCompat.BubbleMetadata.toPlatform(builder.mBubbleMetadata));
+            LocusIdCompat locusIdCompat = builder.mLocusId;
+            if (locusIdCompat != null) {
+                Api29Impl.setLocusId(this.mBuilder, locusIdCompat.toLocusId());
+            }
+        }
+        if (i5 >= 31 && (i = builder.mFgsDeferBehavior) != 0) {
+            Api31Impl.setForegroundServiceBehavior(this.mBuilder, i);
+        }
+        if (builder.mSilent) {
+            if (this.mBuilderCompat.mGroupSummary) {
+                this.mGroupAlertBehavior = 2;
+            } else {
+                this.mGroupAlertBehavior = 1;
+            }
+            this.mBuilder.setVibrate(null);
+            this.mBuilder.setSound(null);
+            int i6 = notification.defaults & (-4);
+            notification.defaults = i6;
+            this.mBuilder.setDefaults(i6);
+            if (TextUtils.isEmpty(this.mBuilderCompat.mGroupKey)) {
+                Api20Impl.setGroup(this.mBuilder, NotificationCompat.GROUP_KEY_SILENT);
+            }
+            Api26Impl.setGroupAlertBehavior(this.mBuilder, this.mGroupAlertBehavior);
+        }
+    }
+
+    @Nullable
+    private static List<String> combineLists(@Nullable List<String> list, @Nullable List<String> list2) {
+        if (list == null) {
+            return list2;
+        }
+        if (list2 == null) {
+            return list;
+        }
+        ArraySet arraySet = new ArraySet(list.size() + list2.size());
+        arraySet.addAll(list);
+        arraySet.addAll(list2);
+        return new ArrayList(arraySet);
+    }
+
+    @Nullable
+    private static List<String> getPeople(@Nullable List<Person> list) {
+        if (list == null) {
+            return null;
+        }
+        ArrayList arrayList = new ArrayList(list.size());
+        Iterator<Person> it = list.iterator();
+        while (it.hasNext()) {
+            arrayList.add(it.next().resolveToLegacyUri());
+        }
+        return arrayList;
+    }
+
+    public Notification build() {
+        Bundle extras;
+        RemoteViews makeHeadsUpContentView;
+        RemoteViews makeBigContentView;
+        NotificationCompat.Style style = this.mBuilderCompat.mStyle;
+        if (style != null) {
+            style.apply(this);
+        }
+        RemoteViews makeContentView = style != null ? style.makeContentView(this) : null;
+        Notification buildInternal = buildInternal();
+        if (makeContentView != null) {
+            buildInternal.contentView = makeContentView;
+        } else {
+            RemoteViews remoteViews = this.mBuilderCompat.mContentView;
+            if (remoteViews != null) {
+                buildInternal.contentView = remoteViews;
+            }
+        }
+        if (style != null && (makeBigContentView = style.makeBigContentView(this)) != null) {
+            buildInternal.bigContentView = makeBigContentView;
+        }
+        if (style != null && (makeHeadsUpContentView = this.mBuilderCompat.mStyle.makeHeadsUpContentView(this)) != null) {
+            buildInternal.headsUpContentView = makeHeadsUpContentView;
+        }
+        if (style != null && (extras = NotificationCompat.getExtras(buildInternal)) != null) {
+            style.addCompatExtras(extras);
+        }
+        return buildInternal;
+    }
+
+    private void addAction(NotificationCompat.Action action) {
+        Bundle bundle;
+        IconCompat iconCompat = action.getIconCompat();
+        Notification.Action.Builder createBuilder = Api23Impl.createBuilder(iconCompat != null ? iconCompat.toIcon() : null, action.getTitle(), action.getActionIntent());
+        if (action.getRemoteInputs() != null) {
+            for (android.app.RemoteInput remoteInput : RemoteInput.fromCompat(action.getRemoteInputs())) {
+                Api20Impl.addRemoteInput(createBuilder, remoteInput);
+            }
+        }
+        if (action.getExtras() != null) {
+            bundle = new Bundle(action.getExtras());
+        } else {
+            bundle = new Bundle();
+        }
+        bundle.putBoolean("android.support.allowGeneratedReplies", action.getAllowGeneratedReplies());
+        int i = Build.VERSION.SDK_INT;
+        Api24Impl.setAllowGeneratedReplies(createBuilder, action.getAllowGeneratedReplies());
+        bundle.putInt("android.support.action.semanticAction", action.getSemanticAction());
+        if (i >= 28) {
+            Api28Impl.setSemanticAction(createBuilder, action.getSemanticAction());
+        }
+        if (i >= 29) {
+            Api29Impl.setContextual(createBuilder, action.isContextual());
+        }
+        if (i >= 31) {
+            Api31Impl.setAuthenticationRequired(createBuilder, action.isAuthenticationRequired());
+        }
+        bundle.putBoolean("android.support.action.showsUserInterface", action.getShowsUserInterface());
+        Api20Impl.addExtras(createBuilder, bundle);
+        Api20Impl.addAction(this.mBuilder, Api20Impl.build(createBuilder));
+    }
+
+    public Notification buildInternal() {
+        return this.mBuilder.build();
+    }
+
+    private void removeSoundAndVibration(Notification notification) {
+        notification.sound = null;
+        notification.vibrate = null;
+        notification.defaults &= -4;
+    }
+
+    @RequiresApi(20)
+    public static class Api20Impl {
+        private Api20Impl() {
+        }
+
+        public static Notification.Action.Builder createBuilder(int i, CharSequence charSequence, PendingIntent pendingIntent) {
+            return new Notification.Action.Builder(i, charSequence, pendingIntent);
+        }
+
+        public static Notification.Action.Builder addRemoteInput(Notification.Action.Builder builder, android.app.RemoteInput remoteInput) {
+            return builder.addRemoteInput(remoteInput);
+        }
+
+        public static Notification.Action.Builder addExtras(Notification.Action.Builder builder, Bundle bundle) {
+            return builder.addExtras(bundle);
+        }
+
+        public static Notification.Builder addAction(Notification.Builder builder, Notification.Action action) {
+            return builder.addAction(action);
+        }
+
+        public static Notification.Action build(Notification.Action.Builder builder) {
+            return builder.build();
+        }
+
+        public static String getGroup(Notification notification) {
+            return notification.getGroup();
+        }
+
+        public static Notification.Builder setGroup(Notification.Builder builder, String str) {
+            return builder.setGroup(str);
+        }
+
+        public static Notification.Builder setGroupSummary(Notification.Builder builder, boolean z) {
+            return builder.setGroupSummary(z);
+        }
+
+        public static Notification.Builder setLocalOnly(Notification.Builder builder, boolean z) {
+            return builder.setLocalOnly(z);
+        }
+
+        public static Notification.Builder setSortKey(Notification.Builder builder, String str) {
+            return builder.setSortKey(str);
+        }
+    }
+
+    @RequiresApi(21)
+    public static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        public static Notification.Builder addPerson(Notification.Builder builder, String str) {
+            return builder.addPerson(str);
+        }
+
+        public static Notification.Builder setCategory(Notification.Builder builder, String str) {
+            return builder.setCategory(str);
+        }
+
+        public static Notification.Builder setColor(Notification.Builder builder, int i) {
+            return builder.setColor(i);
+        }
+
+        public static Notification.Builder setVisibility(Notification.Builder builder, int i) {
+            return builder.setVisibility(i);
+        }
+
+        public static Notification.Builder setPublicVersion(Notification.Builder builder, Notification notification) {
+            return builder.setPublicVersion(notification);
+        }
+
+        public static Notification.Builder setSound(Notification.Builder builder, Uri uri, Object obj) {
+            return builder.setSound(uri, (AudioAttributes) obj);
+        }
+    }
+
+    @RequiresApi(23)
+    public static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        public static Notification.Action.Builder createBuilder(Icon icon, CharSequence charSequence, PendingIntent pendingIntent) {
+            return new Notification.Action.Builder(icon, charSequence, pendingIntent);
+        }
+
+        public static Notification.Builder setSmallIcon(Notification.Builder builder, Object obj) {
+            return builder.setSmallIcon((Icon) obj);
+        }
+
+        public static Notification.Builder setLargeIcon(Notification.Builder builder, Icon icon) {
+            return builder.setLargeIcon(icon);
+        }
+    }
+
+    @RequiresApi(24)
+    public static class Api24Impl {
+        private Api24Impl() {
+        }
+
+        public static Notification.Action.Builder setAllowGeneratedReplies(Notification.Action.Builder builder, boolean z) {
+            return builder.setAllowGeneratedReplies(z);
+        }
+
+        public static Notification.Builder setRemoteInputHistory(Notification.Builder builder, CharSequence[] charSequenceArr) {
+            return builder.setRemoteInputHistory(charSequenceArr);
+        }
+
+        public static Notification.Builder setCustomContentView(Notification.Builder builder, RemoteViews remoteViews) {
+            return builder.setCustomContentView(remoteViews);
+        }
+
+        public static Notification.Builder setCustomBigContentView(Notification.Builder builder, RemoteViews remoteViews) {
+            return builder.setCustomBigContentView(remoteViews);
+        }
+
+        public static Notification.Builder setCustomHeadsUpContentView(Notification.Builder builder, RemoteViews remoteViews) {
+            return builder.setCustomHeadsUpContentView(remoteViews);
+        }
+    }
+
+    @RequiresApi(26)
+    public static class Api26Impl {
+        private Api26Impl() {
+        }
+
+        public static Notification.Builder createBuilder(Context context, String str) {
+            return new Notification.Builder(context, str);
+        }
+
+        public static Notification.Builder setGroupAlertBehavior(Notification.Builder builder, int i) {
+            return builder.setGroupAlertBehavior(i);
+        }
+
+        public static Notification.Builder setColorized(Notification.Builder builder, boolean z) {
+            return builder.setColorized(z);
+        }
+
+        public static Notification.Builder setBadgeIconType(Notification.Builder builder, int i) {
+            return builder.setBadgeIconType(i);
+        }
+
+        public static Notification.Builder setSettingsText(Notification.Builder builder, CharSequence charSequence) {
+            return builder.setSettingsText(charSequence);
+        }
+
+        public static Notification.Builder setShortcutId(Notification.Builder builder, String str) {
+            return builder.setShortcutId(str);
+        }
+
+        public static Notification.Builder setTimeoutAfter(Notification.Builder builder, long j) {
+            return builder.setTimeoutAfter(j);
+        }
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static Notification.Action.Builder setSemanticAction(Notification.Action.Builder builder, int i) {
+            return builder.setSemanticAction(i);
+        }
+
+        public static Notification.Builder addPerson(Notification.Builder builder, android.app.Person person) {
+            return builder.addPerson(person);
+        }
+    }
+
+    @RequiresApi(29)
+    public static class Api29Impl {
+        private Api29Impl() {
+        }
+
+        public static Notification.Action.Builder setContextual(Notification.Action.Builder builder, boolean z) {
+            return builder.setContextual(z);
+        }
+
+        public static Notification.Builder setLocusId(Notification.Builder builder, Object obj) {
+            return builder.setLocusId((LocusId) obj);
+        }
+
+        public static Notification.Builder setBubbleMetadata(Notification.Builder builder, Notification.BubbleMetadata bubbleMetadata) {
+            return builder.setBubbleMetadata(bubbleMetadata);
+        }
+
+        public static Notification.Builder setAllowSystemGeneratedContextualActions(Notification.Builder builder, boolean z) {
+            return builder.setAllowSystemGeneratedContextualActions(z);
+        }
+    }
+
+    @RequiresApi(31)
+    public static class Api31Impl {
+        private Api31Impl() {
+        }
+
+        public static Notification.Action.Builder setAuthenticationRequired(Notification.Action.Builder builder, boolean z) {
+            return builder.setAuthenticationRequired(z);
+        }
+
+        public static Notification.Builder setForegroundServiceBehavior(Notification.Builder builder, int i) {
+            return builder.setForegroundServiceBehavior(i);
+        }
+    }
+}

decompiled/sources/androidx/core/app/NotificationCompatExtras.java

@@ -0,0 +1,14 @@
+package androidx.core.app;
+
+/* loaded from: classes.dex */
+public final class NotificationCompatExtras {
+    public static final String EXTRA_ACTION_EXTRAS = "android.support.actionExtras";
+    public static final String EXTRA_GROUP_KEY = "android.support.groupKey";
+    public static final String EXTRA_GROUP_SUMMARY = "android.support.isGroupSummary";
+    public static final String EXTRA_LOCAL_ONLY = "android.support.localOnly";
+    public static final String EXTRA_REMOTE_INPUTS = "android.support.remoteInputs";
+    public static final String EXTRA_SORT_KEY = "android.support.sortKey";
+
+    private NotificationCompatExtras() {
+    }
+}

decompiled/sources/androidx/core/app/NotificationCompatJellybean.java

@@ -0,0 +1,290 @@
+package androidx.core.app;
+
+import android.app.Notification;
+import android.app.PendingIntent;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.util.Log;
+import android.util.SparseArray;
+import androidx.core.app.NotificationCompat;
+import androidx.core.graphics.drawable.IconCompat;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+class NotificationCompatJellybean {
+    static final String EXTRA_ALLOW_GENERATED_REPLIES = "android.support.allowGeneratedReplies";
+    static final String EXTRA_DATA_ONLY_REMOTE_INPUTS = "android.support.dataRemoteInputs";
+    private static final String KEY_ACTION_INTENT = "actionIntent";
+    private static final String KEY_ALLOWED_DATA_TYPES = "allowedDataTypes";
+    private static final String KEY_ALLOW_FREE_FORM_INPUT = "allowFreeFormInput";
+    private static final String KEY_CHOICES = "choices";
+    private static final String KEY_DATA_ONLY_REMOTE_INPUTS = "dataOnlyRemoteInputs";
+    private static final String KEY_EXTRAS = "extras";
+    private static final String KEY_ICON = "icon";
+    private static final String KEY_LABEL = "label";
+    private static final String KEY_REMOTE_INPUTS = "remoteInputs";
+    private static final String KEY_RESULT_KEY = "resultKey";
+    private static final String KEY_SEMANTIC_ACTION = "semanticAction";
+    private static final String KEY_SHOWS_USER_INTERFACE = "showsUserInterface";
+    private static final String KEY_TITLE = "title";
+    public static final String TAG = "NotificationCompat";
+    private static Field sActionIconField;
+    private static Field sActionIntentField;
+    private static Field sActionTitleField;
+    private static boolean sActionsAccessFailed;
+    private static Field sActionsField;
+    private static Field sExtrasField;
+    private static boolean sExtrasFieldAccessFailed;
+    private static final Object sExtrasLock = new Object();
+    private static final Object sActionsLock = new Object();
+
+    public static SparseArray<Bundle> buildActionExtrasMap(List<Bundle> list) {
+        int size = list.size();
+        SparseArray<Bundle> sparseArray = null;
+        for (int i = 0; i < size; i++) {
+            Bundle bundle = list.get(i);
+            if (bundle != null) {
+                if (sparseArray == null) {
+                    sparseArray = new SparseArray<>();
+                }
+                sparseArray.put(i, bundle);
+            }
+        }
+        return sparseArray;
+    }
+
+    public static Bundle getExtras(Notification notification) {
+        synchronized (sExtrasLock) {
+            if (sExtrasFieldAccessFailed) {
+                return null;
+            }
+            try {
+                if (sExtrasField == null) {
+                    Field declaredField = Notification.class.getDeclaredField("extras");
+                    if (!Bundle.class.isAssignableFrom(declaredField.getType())) {
+                        Log.e(TAG, "Notification.extras field is not of type Bundle");
+                        sExtrasFieldAccessFailed = true;
+                        return null;
+                    }
+                    declaredField.setAccessible(true);
+                    sExtrasField = declaredField;
+                }
+                Bundle bundle = (Bundle) sExtrasField.get(notification);
+                if (bundle == null) {
+                    bundle = new Bundle();
+                    sExtrasField.set(notification, bundle);
+                }
+                return bundle;
+            } catch (IllegalAccessException e) {
+                Log.e(TAG, "Unable to access notification extras", e);
+                sExtrasFieldAccessFailed = true;
+                return null;
+            } catch (NoSuchFieldException e2) {
+                Log.e(TAG, "Unable to access notification extras", e2);
+                sExtrasFieldAccessFailed = true;
+                return null;
+            }
+        }
+    }
+
+    public static NotificationCompat.Action readAction(int i, CharSequence charSequence, PendingIntent pendingIntent, Bundle bundle) {
+        RemoteInput[] remoteInputArr;
+        RemoteInput[] remoteInputArr2;
+        boolean z;
+        if (bundle != null) {
+            remoteInputArr = fromBundleArray(getBundleArrayFromBundle(bundle, NotificationCompatExtras.EXTRA_REMOTE_INPUTS));
+            remoteInputArr2 = fromBundleArray(getBundleArrayFromBundle(bundle, EXTRA_DATA_ONLY_REMOTE_INPUTS));
+            z = bundle.getBoolean(EXTRA_ALLOW_GENERATED_REPLIES);
+        } else {
+            remoteInputArr = null;
+            remoteInputArr2 = null;
+            z = false;
+        }
+        return new NotificationCompat.Action(i, charSequence, pendingIntent, bundle, remoteInputArr, remoteInputArr2, z, 0, true, false, false);
+    }
+
+    public static Bundle writeActionAndGetExtras(Notification.Builder builder, NotificationCompat.Action action) {
+        IconCompat iconCompat = action.getIconCompat();
+        builder.addAction(iconCompat != null ? iconCompat.getResId() : 0, action.getTitle(), action.getActionIntent());
+        Bundle bundle = new Bundle(action.getExtras());
+        if (action.getRemoteInputs() != null) {
+            bundle.putParcelableArray(NotificationCompatExtras.EXTRA_REMOTE_INPUTS, toBundleArray(action.getRemoteInputs()));
+        }
+        if (action.getDataOnlyRemoteInputs() != null) {
+            bundle.putParcelableArray(EXTRA_DATA_ONLY_REMOTE_INPUTS, toBundleArray(action.getDataOnlyRemoteInputs()));
+        }
+        bundle.putBoolean(EXTRA_ALLOW_GENERATED_REPLIES, action.getAllowGeneratedReplies());
+        return bundle;
+    }
+
+    public static int getActionCount(Notification notification) {
+        int length;
+        synchronized (sActionsLock) {
+            try {
+                Object[] actionObjectsLocked = getActionObjectsLocked(notification);
+                length = actionObjectsLocked != null ? actionObjectsLocked.length : 0;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return length;
+    }
+
+    public static NotificationCompat.Action getAction(Notification notification, int i) {
+        SparseArray sparseParcelableArray;
+        synchronized (sActionsLock) {
+            try {
+                try {
+                    Object[] actionObjectsLocked = getActionObjectsLocked(notification);
+                    if (actionObjectsLocked != null) {
+                        Object obj = actionObjectsLocked[i];
+                        Bundle extras = getExtras(notification);
+                        return readAction(sActionIconField.getInt(obj), (CharSequence) sActionTitleField.get(obj), (PendingIntent) sActionIntentField.get(obj), (extras == null || (sparseParcelableArray = extras.getSparseParcelableArray(NotificationCompatExtras.EXTRA_ACTION_EXTRAS)) == null) ? null : (Bundle) sparseParcelableArray.get(i));
+                    }
+                } catch (IllegalAccessException e) {
+                    Log.e(TAG, "Unable to access notification actions", e);
+                    sActionsAccessFailed = true;
+                }
+                return null;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    private static Object[] getActionObjectsLocked(Notification notification) {
+        synchronized (sActionsLock) {
+            if (!ensureActionReflectionReadyLocked()) {
+                return null;
+            }
+            try {
+                return (Object[]) sActionsField.get(notification);
+            } catch (IllegalAccessException e) {
+                Log.e(TAG, "Unable to access notification actions", e);
+                sActionsAccessFailed = true;
+                return null;
+            }
+        }
+    }
+
+    private static boolean ensureActionReflectionReadyLocked() {
+        if (sActionsAccessFailed) {
+            return false;
+        }
+        try {
+            if (sActionsField == null) {
+                Class<?> cls = Class.forName("android.app.Notification$Action");
+                sActionIconField = cls.getDeclaredField("icon");
+                sActionTitleField = cls.getDeclaredField("title");
+                sActionIntentField = cls.getDeclaredField(KEY_ACTION_INTENT);
+                Field declaredField = Notification.class.getDeclaredField("actions");
+                sActionsField = declaredField;
+                declaredField.setAccessible(true);
+            }
+        } catch (ClassNotFoundException e) {
+            Log.e(TAG, "Unable to access notification actions", e);
+            sActionsAccessFailed = true;
+        } catch (NoSuchFieldException e2) {
+            Log.e(TAG, "Unable to access notification actions", e2);
+            sActionsAccessFailed = true;
+        }
+        return !sActionsAccessFailed;
+    }
+
+    public static NotificationCompat.Action getActionFromBundle(Bundle bundle) {
+        Bundle bundle2 = bundle.getBundle("extras");
+        return new NotificationCompat.Action(bundle.getInt("icon"), bundle.getCharSequence("title"), (PendingIntent) bundle.getParcelable(KEY_ACTION_INTENT), bundle.getBundle("extras"), fromBundleArray(getBundleArrayFromBundle(bundle, KEY_REMOTE_INPUTS)), fromBundleArray(getBundleArrayFromBundle(bundle, KEY_DATA_ONLY_REMOTE_INPUTS)), bundle2 != null ? bundle2.getBoolean(EXTRA_ALLOW_GENERATED_REPLIES, false) : false, bundle.getInt(KEY_SEMANTIC_ACTION), bundle.getBoolean(KEY_SHOWS_USER_INTERFACE), false, false);
+    }
+
+    public static Bundle getBundleForAction(NotificationCompat.Action action) {
+        Bundle bundle;
+        Bundle bundle2 = new Bundle();
+        IconCompat iconCompat = action.getIconCompat();
+        bundle2.putInt("icon", iconCompat != null ? iconCompat.getResId() : 0);
+        bundle2.putCharSequence("title", action.getTitle());
+        bundle2.putParcelable(KEY_ACTION_INTENT, action.getActionIntent());
+        if (action.getExtras() != null) {
+            bundle = new Bundle(action.getExtras());
+        } else {
+            bundle = new Bundle();
+        }
+        bundle.putBoolean(EXTRA_ALLOW_GENERATED_REPLIES, action.getAllowGeneratedReplies());
+        bundle2.putBundle("extras", bundle);
+        bundle2.putParcelableArray(KEY_REMOTE_INPUTS, toBundleArray(action.getRemoteInputs()));
+        bundle2.putBoolean(KEY_SHOWS_USER_INTERFACE, action.getShowsUserInterface());
+        bundle2.putInt(KEY_SEMANTIC_ACTION, action.getSemanticAction());
+        return bundle2;
+    }
+
+    private static RemoteInput fromBundle(Bundle bundle) {
+        ArrayList<String> stringArrayList = bundle.getStringArrayList(KEY_ALLOWED_DATA_TYPES);
+        HashSet hashSet = new HashSet();
+        if (stringArrayList != null) {
+            Iterator<String> it = stringArrayList.iterator();
+            while (it.hasNext()) {
+                hashSet.add(it.next());
+            }
+        }
+        return new RemoteInput(bundle.getString(KEY_RESULT_KEY), bundle.getCharSequence("label"), bundle.getCharSequenceArray(KEY_CHOICES), bundle.getBoolean(KEY_ALLOW_FREE_FORM_INPUT), 0, bundle.getBundle("extras"), hashSet);
+    }
+
+    private static Bundle toBundle(RemoteInput remoteInput) {
+        Bundle bundle = new Bundle();
+        bundle.putString(KEY_RESULT_KEY, remoteInput.getResultKey());
+        bundle.putCharSequence("label", remoteInput.getLabel());
+        bundle.putCharSequenceArray(KEY_CHOICES, remoteInput.getChoices());
+        bundle.putBoolean(KEY_ALLOW_FREE_FORM_INPUT, remoteInput.getAllowFreeFormInput());
+        bundle.putBundle("extras", remoteInput.getExtras());
+        Set<String> allowedDataTypes = remoteInput.getAllowedDataTypes();
+        if (allowedDataTypes != null && !allowedDataTypes.isEmpty()) {
+            ArrayList<String> arrayList = new ArrayList<>(allowedDataTypes.size());
+            Iterator<String> it = allowedDataTypes.iterator();
+            while (it.hasNext()) {
+                arrayList.add(it.next());
+            }
+            bundle.putStringArrayList(KEY_ALLOWED_DATA_TYPES, arrayList);
+        }
+        return bundle;
+    }
+
+    private static RemoteInput[] fromBundleArray(Bundle[] bundleArr) {
+        if (bundleArr == null) {
+            return null;
+        }
+        RemoteInput[] remoteInputArr = new RemoteInput[bundleArr.length];
+        for (int i = 0; i < bundleArr.length; i++) {
+            remoteInputArr[i] = fromBundle(bundleArr[i]);
+        }
+        return remoteInputArr;
+    }
+
+    private static Bundle[] toBundleArray(RemoteInput[] remoteInputArr) {
+        if (remoteInputArr == null) {
+            return null;
+        }
+        Bundle[] bundleArr = new Bundle[remoteInputArr.length];
+        for (int i = 0; i < remoteInputArr.length; i++) {
+            bundleArr[i] = toBundle(remoteInputArr[i]);
+        }
+        return bundleArr;
+    }
+
+    private static Bundle[] getBundleArrayFromBundle(Bundle bundle, String str) {
+        Parcelable[] parcelableArray = bundle.getParcelableArray(str);
+        if ((parcelableArray instanceof Bundle[]) || parcelableArray == null) {
+            return (Bundle[]) parcelableArray;
+        }
+        Bundle[] bundleArr = (Bundle[]) Arrays.copyOf(parcelableArray, parcelableArray.length, Bundle[].class);
+        bundle.putParcelableArray(str, bundleArr);
+        return bundleArr;
+    }
+
+    private NotificationCompatJellybean() {
+    }
+}

decompiled/sources/androidx/core/app/NotificationCompatSideChannelService.java

@@ -0,0 +1,73 @@
+package androidx.core.app;
+
+import android.app.Notification;
+import android.app.Service;
+import android.content.Intent;
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.support.v4.app.INotificationSideChannel;
+import androidx.annotation.DeprecatedSinceApi;
+
+/* loaded from: classes.dex */
+public abstract class NotificationCompatSideChannelService extends Service {
+    public abstract void cancel(String str, int i, String str2);
+
+    public abstract void cancelAll(String str);
+
+    public abstract void notify(String str, int i, String str2, Notification notification);
+
+    @Override // android.app.Service
+    @DeprecatedSinceApi(api = 19, message = "SDKs past 19 have no need for side channeling.")
+    public IBinder onBind(Intent intent) {
+        intent.getAction().equals(NotificationManagerCompat.ACTION_BIND_SIDE_CHANNEL);
+        return null;
+    }
+
+    public class NotificationSideChannelStub extends INotificationSideChannel.Stub {
+        public NotificationSideChannelStub() {
+        }
+
+        @Override // android.support.v4.app.INotificationSideChannel
+        public void notify(String str, int i, String str2, Notification notification) throws RemoteException {
+            NotificationCompatSideChannelService.this.checkPermission(Binder.getCallingUid(), str);
+            long clearCallingIdentity = Binder.clearCallingIdentity();
+            try {
+                NotificationCompatSideChannelService.this.notify(str, i, str2, notification);
+            } finally {
+                Binder.restoreCallingIdentity(clearCallingIdentity);
+            }
+        }
+
+        @Override // android.support.v4.app.INotificationSideChannel
+        public void cancel(String str, int i, String str2) throws RemoteException {
+            NotificationCompatSideChannelService.this.checkPermission(Binder.getCallingUid(), str);
+            long clearCallingIdentity = Binder.clearCallingIdentity();
+            try {
+                NotificationCompatSideChannelService.this.cancel(str, i, str2);
+            } finally {
+                Binder.restoreCallingIdentity(clearCallingIdentity);
+            }
+        }
+
+        @Override // android.support.v4.app.INotificationSideChannel
+        public void cancelAll(String str) {
+            NotificationCompatSideChannelService.this.checkPermission(Binder.getCallingUid(), str);
+            long clearCallingIdentity = Binder.clearCallingIdentity();
+            try {
+                NotificationCompatSideChannelService.this.cancelAll(str);
+            } finally {
+                Binder.restoreCallingIdentity(clearCallingIdentity);
+            }
+        }
+    }
+
+    public void checkPermission(int i, String str) {
+        for (String str2 : getPackageManager().getPackagesForUid(i)) {
+            if (str2.equals(str)) {
+                return;
+            }
+        }
+        throw new SecurityException("NotificationSideChannelService: Uid " + i + " is not authorized for package " + str);
+    }
+}

decompiled/sources/androidx/core/app/NotificationManagerCompat.java

@@ -0,0 +1,836 @@
+package androidx.core.app;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationChannelGroup;
+import android.app.NotificationManager;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.content.pm.ResolveInfo;
+import android.content.pm.ServiceInfo;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.DeadObjectException;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.IBinder;
+import android.os.Message;
+import android.os.RemoteException;
+import android.provider.Settings;
+import android.service.notification.StatusBarNotification;
+import android.support.v4.app.INotificationSideChannel;
+import android.util.Log;
+import androidx.annotation.GuardedBy;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RequiresPermission;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import com.facebook.internal.security.CertificateUtil;
+import com.ironsource.v8;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+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 final class NotificationManagerCompat {
+    public static final String ACTION_BIND_SIDE_CHANNEL = "android.support.BIND_NOTIFICATION_SIDE_CHANNEL";
+    private static final String CHECK_OP_NO_THROW = "checkOpNoThrow";
+    public static final String EXTRA_USE_SIDE_CHANNEL = "android.support.useSideChannel";
+    public static final int IMPORTANCE_DEFAULT = 3;
+    public static final int IMPORTANCE_HIGH = 4;
+    public static final int IMPORTANCE_LOW = 2;
+    public static final int IMPORTANCE_MAX = 5;
+    public static final int IMPORTANCE_MIN = 1;
+    public static final int IMPORTANCE_NONE = 0;
+    public static final int IMPORTANCE_UNSPECIFIED = -1000;
+    public static final int INTERRUPTION_FILTER_ALARMS = 4;
+    public static final int INTERRUPTION_FILTER_ALL = 1;
+    public static final int INTERRUPTION_FILTER_NONE = 3;
+    public static final int INTERRUPTION_FILTER_PRIORITY = 2;
+    public static final int INTERRUPTION_FILTER_UNKNOWN = 0;
+    static final int MAX_SIDE_CHANNEL_SDK_VERSION = 19;
+    private static final String OP_POST_NOTIFICATION = "OP_POST_NOTIFICATION";
+    private static final String SETTING_ENABLED_NOTIFICATION_LISTENERS = "enabled_notification_listeners";
+    private static final int SIDE_CHANNEL_RETRY_BASE_INTERVAL_MS = 1000;
+    private static final int SIDE_CHANNEL_RETRY_MAX_COUNT = 6;
+    private static final String TAG = "NotifManCompat";
+
+    @GuardedBy("sEnabledNotificationListenersLock")
+    private static String sEnabledNotificationListeners;
+
+    @GuardedBy("sLock")
+    private static SideChannelManager sSideChannelManager;
+    private final Context mContext;
+    private final NotificationManager mNotificationManager;
+    private static final Object sEnabledNotificationListenersLock = new Object();
+
+    @GuardedBy("sEnabledNotificationListenersLock")
+    private static Set<String> sEnabledNotificationListenerPackages = new HashSet();
+    private static final Object sLock = new Object();
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public @interface InterruptionFilter {
+    }
+
+    public interface Task {
+        void send(INotificationSideChannel iNotificationSideChannel) throws RemoteException;
+    }
+
+    @NonNull
+    public static NotificationManagerCompat from(@NonNull Context context) {
+        return new NotificationManagerCompat(context);
+    }
+
+    private NotificationManagerCompat(Context context) {
+        this.mContext = context;
+        this.mNotificationManager = (NotificationManager) context.getSystemService("notification");
+    }
+
+    @VisibleForTesting
+    public NotificationManagerCompat(@NonNull NotificationManager notificationManager, @NonNull Context context) {
+        this.mContext = context;
+        this.mNotificationManager = notificationManager;
+    }
+
+    public void cancel(int i) {
+        cancel(null, i);
+    }
+
+    public void cancel(@Nullable String str, int i) {
+        this.mNotificationManager.cancel(str, i);
+    }
+
+    public void cancelAll() {
+        this.mNotificationManager.cancelAll();
+    }
+
+    @RequiresPermission("android.permission.POST_NOTIFICATIONS")
+    public void notify(int i, @NonNull Notification notification) {
+        notify(null, i, notification);
+    }
+
+    @RequiresPermission("android.permission.POST_NOTIFICATIONS")
+    public void notify(@Nullable String str, int i, @NonNull Notification notification) {
+        if (useSideChannelForNotification(notification)) {
+            pushSideChannelQueue(new NotifyTask(this.mContext.getPackageName(), i, str, notification));
+            this.mNotificationManager.cancel(str, i);
+        } else {
+            this.mNotificationManager.notify(str, i, notification);
+        }
+    }
+
+    @RequiresPermission("android.permission.POST_NOTIFICATIONS")
+    public void notify(@NonNull List<NotificationWithIdAndTag> list) {
+        int size = list.size();
+        for (int i = 0; i < size; i++) {
+            NotificationWithIdAndTag notificationWithIdAndTag = list.get(i);
+            notify(notificationWithIdAndTag.mTag, notificationWithIdAndTag.mId, notificationWithIdAndTag.mNotification);
+        }
+    }
+
+    public static class NotificationWithIdAndTag {
+        final int mId;
+        Notification mNotification;
+        final String mTag;
+
+        public NotificationWithIdAndTag(@Nullable String str, int i, @NonNull Notification notification) {
+            this.mTag = str;
+            this.mId = i;
+            this.mNotification = notification;
+        }
+
+        public NotificationWithIdAndTag(int i, @NonNull Notification notification) {
+            this(null, i, notification);
+        }
+    }
+
+    @NonNull
+    public List<StatusBarNotification> getActiveNotifications() {
+        return Api23Impl.getActiveNotifications(this.mNotificationManager);
+    }
+
+    public boolean areNotificationsEnabled() {
+        return Api24Impl.areNotificationsEnabled(this.mNotificationManager);
+    }
+
+    public int getImportance() {
+        return Api24Impl.getImportance(this.mNotificationManager);
+    }
+
+    public void createNotificationChannel(@NonNull NotificationChannel notificationChannel) {
+        Api26Impl.createNotificationChannel(this.mNotificationManager, notificationChannel);
+    }
+
+    public void createNotificationChannel(@NonNull NotificationChannelCompat notificationChannelCompat) {
+        createNotificationChannel(notificationChannelCompat.getNotificationChannel());
+    }
+
+    public void createNotificationChannelGroup(@NonNull NotificationChannelGroup notificationChannelGroup) {
+        Api26Impl.createNotificationChannelGroup(this.mNotificationManager, notificationChannelGroup);
+    }
+
+    public void createNotificationChannelGroup(@NonNull NotificationChannelGroupCompat notificationChannelGroupCompat) {
+        createNotificationChannelGroup(notificationChannelGroupCompat.getNotificationChannelGroup());
+    }
+
+    public void createNotificationChannels(@NonNull List<NotificationChannel> list) {
+        Api26Impl.createNotificationChannels(this.mNotificationManager, list);
+    }
+
+    public void createNotificationChannelsCompat(@NonNull List<NotificationChannelCompat> list) {
+        if (list.isEmpty()) {
+            return;
+        }
+        ArrayList arrayList = new ArrayList(list.size());
+        Iterator<NotificationChannelCompat> it = list.iterator();
+        while (it.hasNext()) {
+            arrayList.add(it.next().getNotificationChannel());
+        }
+        Api26Impl.createNotificationChannels(this.mNotificationManager, arrayList);
+    }
+
+    public void createNotificationChannelGroups(@NonNull List<NotificationChannelGroup> list) {
+        Api26Impl.createNotificationChannelGroups(this.mNotificationManager, list);
+    }
+
+    public void createNotificationChannelGroupsCompat(@NonNull List<NotificationChannelGroupCompat> list) {
+        if (list.isEmpty()) {
+            return;
+        }
+        ArrayList arrayList = new ArrayList(list.size());
+        Iterator<NotificationChannelGroupCompat> it = list.iterator();
+        while (it.hasNext()) {
+            arrayList.add(it.next().getNotificationChannelGroup());
+        }
+        Api26Impl.createNotificationChannelGroups(this.mNotificationManager, arrayList);
+    }
+
+    public void deleteNotificationChannel(@NonNull String str) {
+        Api26Impl.deleteNotificationChannel(this.mNotificationManager, str);
+    }
+
+    public void deleteNotificationChannelGroup(@NonNull String str) {
+        Api26Impl.deleteNotificationChannelGroup(this.mNotificationManager, str);
+    }
+
+    public void deleteUnlistedNotificationChannels(@NonNull Collection<String> collection) {
+        for (NotificationChannel notificationChannel : Api26Impl.getNotificationChannels(this.mNotificationManager)) {
+            if (!collection.contains(Api26Impl.getId(notificationChannel)) && (Build.VERSION.SDK_INT < 30 || !collection.contains(Api30Impl.getParentChannelId(notificationChannel)))) {
+                Api26Impl.deleteNotificationChannel(this.mNotificationManager, Api26Impl.getId(notificationChannel));
+            }
+        }
+    }
+
+    @Nullable
+    public NotificationChannel getNotificationChannel(@NonNull String str) {
+        return Api26Impl.getNotificationChannel(this.mNotificationManager, str);
+    }
+
+    @Nullable
+    public NotificationChannelCompat getNotificationChannelCompat(@NonNull String str) {
+        NotificationChannel notificationChannel = getNotificationChannel(str);
+        if (notificationChannel != null) {
+            return new NotificationChannelCompat(notificationChannel);
+        }
+        return null;
+    }
+
+    @Nullable
+    public NotificationChannel getNotificationChannel(@NonNull String str, @NonNull String str2) {
+        if (Build.VERSION.SDK_INT >= 30) {
+            return Api30Impl.getNotificationChannel(this.mNotificationManager, str, str2);
+        }
+        return getNotificationChannel(str);
+    }
+
+    @Nullable
+    public NotificationChannelCompat getNotificationChannelCompat(@NonNull String str, @NonNull String str2) {
+        NotificationChannel notificationChannel = getNotificationChannel(str, str2);
+        if (notificationChannel != null) {
+            return new NotificationChannelCompat(notificationChannel);
+        }
+        return null;
+    }
+
+    @Nullable
+    public NotificationChannelGroup getNotificationChannelGroup(@NonNull String str) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.getNotificationChannelGroup(this.mNotificationManager, str);
+        }
+        for (NotificationChannelGroup notificationChannelGroup : getNotificationChannelGroups()) {
+            if (Api26Impl.getId(notificationChannelGroup).equals(str)) {
+                return notificationChannelGroup;
+            }
+        }
+        return null;
+    }
+
+    @Nullable
+    public NotificationChannelGroupCompat getNotificationChannelGroupCompat(@NonNull String str) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            NotificationChannelGroup notificationChannelGroup = getNotificationChannelGroup(str);
+            if (notificationChannelGroup != null) {
+                return new NotificationChannelGroupCompat(notificationChannelGroup);
+            }
+            return null;
+        }
+        NotificationChannelGroup notificationChannelGroup2 = getNotificationChannelGroup(str);
+        if (notificationChannelGroup2 != null) {
+            return new NotificationChannelGroupCompat(notificationChannelGroup2, getNotificationChannels());
+        }
+        return null;
+    }
+
+    @NonNull
+    public List<NotificationChannel> getNotificationChannels() {
+        return Api26Impl.getNotificationChannels(this.mNotificationManager);
+    }
+
+    @NonNull
+    public List<NotificationChannelCompat> getNotificationChannelsCompat() {
+        List<NotificationChannel> notificationChannels = getNotificationChannels();
+        if (!notificationChannels.isEmpty()) {
+            ArrayList arrayList = new ArrayList(notificationChannels.size());
+            Iterator<NotificationChannel> it = notificationChannels.iterator();
+            while (it.hasNext()) {
+                arrayList.add(new NotificationChannelCompat(it.next()));
+            }
+            return arrayList;
+        }
+        return Collections.emptyList();
+    }
+
+    @NonNull
+    public List<NotificationChannelGroup> getNotificationChannelGroups() {
+        return Api26Impl.getNotificationChannelGroups(this.mNotificationManager);
+    }
+
+    @NonNull
+    public List<NotificationChannelGroupCompat> getNotificationChannelGroupsCompat() {
+        List<NotificationChannel> notificationChannels;
+        int i = Build.VERSION.SDK_INT;
+        List<NotificationChannelGroup> notificationChannelGroups = getNotificationChannelGroups();
+        if (!notificationChannelGroups.isEmpty()) {
+            if (i >= 28) {
+                notificationChannels = Collections.emptyList();
+            } else {
+                notificationChannels = getNotificationChannels();
+            }
+            ArrayList arrayList = new ArrayList(notificationChannelGroups.size());
+            for (NotificationChannelGroup notificationChannelGroup : notificationChannelGroups) {
+                if (Build.VERSION.SDK_INT >= 28) {
+                    arrayList.add(new NotificationChannelGroupCompat(notificationChannelGroup));
+                } else {
+                    arrayList.add(new NotificationChannelGroupCompat(notificationChannelGroup, notificationChannels));
+                }
+            }
+            return arrayList;
+        }
+        return Collections.emptyList();
+    }
+
+    @NonNull
+    public static Set<String> getEnabledListenerPackages(@NonNull Context context) {
+        Set<String> set;
+        String string = Settings.Secure.getString(context.getContentResolver(), SETTING_ENABLED_NOTIFICATION_LISTENERS);
+        synchronized (sEnabledNotificationListenersLock) {
+            if (string != null) {
+                try {
+                    if (!string.equals(sEnabledNotificationListeners)) {
+                        String[] split = string.split(CertificateUtil.DELIMITER, -1);
+                        HashSet hashSet = new HashSet(split.length);
+                        for (String str : split) {
+                            ComponentName unflattenFromString = ComponentName.unflattenFromString(str);
+                            if (unflattenFromString != null) {
+                                hashSet.add(unflattenFromString.getPackageName());
+                            }
+                        }
+                        sEnabledNotificationListenerPackages = hashSet;
+                        sEnabledNotificationListeners = string;
+                    }
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+            set = sEnabledNotificationListenerPackages;
+        }
+        return set;
+    }
+
+    public boolean canUseFullScreenIntent() {
+        int i = Build.VERSION.SDK_INT;
+        if (i < 29) {
+            return true;
+        }
+        if (i < 34) {
+            return this.mContext.checkSelfPermission("android.permission.USE_FULL_SCREEN_INTENT") == 0;
+        }
+        return Api34Impl.canUseFullScreenIntent(this.mNotificationManager);
+    }
+
+    private static boolean useSideChannelForNotification(Notification notification) {
+        Bundle extras = NotificationCompat.getExtras(notification);
+        return extras != null && extras.getBoolean(EXTRA_USE_SIDE_CHANNEL);
+    }
+
+    public int getCurrentInterruptionFilter() {
+        return Api23Impl.getCurrentInterruptionFilter(this.mNotificationManager);
+    }
+
+    private void pushSideChannelQueue(Task task) {
+        synchronized (sLock) {
+            try {
+                if (sSideChannelManager == null) {
+                    sSideChannelManager = new SideChannelManager(this.mContext.getApplicationContext());
+                }
+                sSideChannelManager.queueTask(task);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public static class SideChannelManager implements Handler.Callback, ServiceConnection {
+        private static final int MSG_QUEUE_TASK = 0;
+        private static final int MSG_RETRY_LISTENER_QUEUE = 3;
+        private static final int MSG_SERVICE_CONNECTED = 1;
+        private static final int MSG_SERVICE_DISCONNECTED = 2;
+        private final Context mContext;
+        private final Handler mHandler;
+        private final HandlerThread mHandlerThread;
+        private final Map<ComponentName, ListenerRecord> mRecordMap = new HashMap();
+        private Set<String> mCachedEnabledPackages = new HashSet();
+
+        public SideChannelManager(Context context) {
+            this.mContext = context;
+            HandlerThread handlerThread = new HandlerThread("NotificationManagerCompat");
+            this.mHandlerThread = handlerThread;
+            handlerThread.start();
+            this.mHandler = new Handler(handlerThread.getLooper(), this);
+        }
+
+        public void queueTask(Task task) {
+            this.mHandler.obtainMessage(0, task).sendToTarget();
+        }
+
+        @Override // android.os.Handler.Callback
+        public boolean handleMessage(Message message) {
+            int i = message.what;
+            if (i == 0) {
+                handleQueueTask((Task) message.obj);
+                return true;
+            }
+            if (i == 1) {
+                ServiceConnectedEvent serviceConnectedEvent = (ServiceConnectedEvent) message.obj;
+                handleServiceConnected(serviceConnectedEvent.componentName, serviceConnectedEvent.iBinder);
+                return true;
+            }
+            if (i == 2) {
+                handleServiceDisconnected((ComponentName) message.obj);
+                return true;
+            }
+            if (i != 3) {
+                return false;
+            }
+            handleRetryListenerQueue((ComponentName) message.obj);
+            return true;
+        }
+
+        private void handleQueueTask(Task task) {
+            updateListenerMap();
+            for (ListenerRecord listenerRecord : this.mRecordMap.values()) {
+                listenerRecord.taskQueue.add(task);
+                processListenerQueue(listenerRecord);
+            }
+        }
+
+        private void handleServiceConnected(ComponentName componentName, IBinder iBinder) {
+            ListenerRecord listenerRecord = this.mRecordMap.get(componentName);
+            if (listenerRecord != null) {
+                listenerRecord.service = INotificationSideChannel.Stub.asInterface(iBinder);
+                listenerRecord.retryCount = 0;
+                processListenerQueue(listenerRecord);
+            }
+        }
+
+        private void handleServiceDisconnected(ComponentName componentName) {
+            ListenerRecord listenerRecord = this.mRecordMap.get(componentName);
+            if (listenerRecord != null) {
+                ensureServiceUnbound(listenerRecord);
+            }
+        }
+
+        private void handleRetryListenerQueue(ComponentName componentName) {
+            ListenerRecord listenerRecord = this.mRecordMap.get(componentName);
+            if (listenerRecord != null) {
+                processListenerQueue(listenerRecord);
+            }
+        }
+
+        @Override // android.content.ServiceConnection
+        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
+            if (Log.isLoggable(NotificationManagerCompat.TAG, 3)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Connected to service ");
+                sb.append(componentName);
+            }
+            this.mHandler.obtainMessage(1, new ServiceConnectedEvent(componentName, iBinder)).sendToTarget();
+        }
+
+        @Override // android.content.ServiceConnection
+        public void onServiceDisconnected(ComponentName componentName) {
+            if (Log.isLoggable(NotificationManagerCompat.TAG, 3)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Disconnected from service ");
+                sb.append(componentName);
+            }
+            this.mHandler.obtainMessage(2, componentName).sendToTarget();
+        }
+
+        private void updateListenerMap() {
+            Set<String> enabledListenerPackages = NotificationManagerCompat.getEnabledListenerPackages(this.mContext);
+            if (enabledListenerPackages.equals(this.mCachedEnabledPackages)) {
+                return;
+            }
+            this.mCachedEnabledPackages = enabledListenerPackages;
+            List<ResolveInfo> queryIntentServices = this.mContext.getPackageManager().queryIntentServices(new Intent().setAction(NotificationManagerCompat.ACTION_BIND_SIDE_CHANNEL), 0);
+            HashSet<ComponentName> hashSet = new HashSet();
+            for (ResolveInfo resolveInfo : queryIntentServices) {
+                if (enabledListenerPackages.contains(resolveInfo.serviceInfo.packageName)) {
+                    ServiceInfo serviceInfo = resolveInfo.serviceInfo;
+                    ComponentName componentName = new ComponentName(serviceInfo.packageName, serviceInfo.name);
+                    if (resolveInfo.serviceInfo.permission != null) {
+                        Log.w(NotificationManagerCompat.TAG, "Permission present on component " + componentName + ", not adding listener record.");
+                    } else {
+                        hashSet.add(componentName);
+                    }
+                }
+            }
+            for (ComponentName componentName2 : hashSet) {
+                if (!this.mRecordMap.containsKey(componentName2)) {
+                    if (Log.isLoggable(NotificationManagerCompat.TAG, 3)) {
+                        StringBuilder sb = new StringBuilder();
+                        sb.append("Adding listener record for ");
+                        sb.append(componentName2);
+                    }
+                    this.mRecordMap.put(componentName2, new ListenerRecord(componentName2));
+                }
+            }
+            Iterator<Map.Entry<ComponentName, ListenerRecord>> it = this.mRecordMap.entrySet().iterator();
+            while (it.hasNext()) {
+                Map.Entry<ComponentName, ListenerRecord> next = it.next();
+                if (!hashSet.contains(next.getKey())) {
+                    if (Log.isLoggable(NotificationManagerCompat.TAG, 3)) {
+                        StringBuilder sb2 = new StringBuilder();
+                        sb2.append("Removing listener record for ");
+                        sb2.append(next.getKey());
+                    }
+                    ensureServiceUnbound(next.getValue());
+                    it.remove();
+                }
+            }
+        }
+
+        private boolean ensureServiceBound(ListenerRecord listenerRecord) {
+            if (listenerRecord.bound) {
+                return true;
+            }
+            boolean bindService = this.mContext.bindService(new Intent(NotificationManagerCompat.ACTION_BIND_SIDE_CHANNEL).setComponent(listenerRecord.componentName), this, 33);
+            listenerRecord.bound = bindService;
+            if (bindService) {
+                listenerRecord.retryCount = 0;
+            } else {
+                Log.w(NotificationManagerCompat.TAG, "Unable to bind to listener " + listenerRecord.componentName);
+                this.mContext.unbindService(this);
+            }
+            return listenerRecord.bound;
+        }
+
+        private void ensureServiceUnbound(ListenerRecord listenerRecord) {
+            if (listenerRecord.bound) {
+                this.mContext.unbindService(this);
+                listenerRecord.bound = false;
+            }
+            listenerRecord.service = null;
+        }
+
+        private void scheduleListenerRetry(ListenerRecord listenerRecord) {
+            if (this.mHandler.hasMessages(3, listenerRecord.componentName)) {
+                return;
+            }
+            int i = listenerRecord.retryCount;
+            int i2 = i + 1;
+            listenerRecord.retryCount = i2;
+            if (i2 > 6) {
+                Log.w(NotificationManagerCompat.TAG, "Giving up on delivering " + listenerRecord.taskQueue.size() + " tasks to " + listenerRecord.componentName + " after " + listenerRecord.retryCount + " retries");
+                listenerRecord.taskQueue.clear();
+                return;
+            }
+            int i3 = (1 << i) * 1000;
+            if (Log.isLoggable(NotificationManagerCompat.TAG, 3)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Scheduling retry for ");
+                sb.append(i3);
+                sb.append(" ms");
+            }
+            this.mHandler.sendMessageDelayed(this.mHandler.obtainMessage(3, listenerRecord.componentName), i3);
+        }
+
+        private void processListenerQueue(ListenerRecord listenerRecord) {
+            if (Log.isLoggable(NotificationManagerCompat.TAG, 3)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Processing component ");
+                sb.append(listenerRecord.componentName);
+                sb.append(", ");
+                sb.append(listenerRecord.taskQueue.size());
+                sb.append(" queued tasks");
+            }
+            if (listenerRecord.taskQueue.isEmpty()) {
+                return;
+            }
+            if (!ensureServiceBound(listenerRecord) || listenerRecord.service == null) {
+                scheduleListenerRetry(listenerRecord);
+                return;
+            }
+            while (true) {
+                Task peek = listenerRecord.taskQueue.peek();
+                if (peek == null) {
+                    break;
+                }
+                try {
+                    if (Log.isLoggable(NotificationManagerCompat.TAG, 3)) {
+                        StringBuilder sb2 = new StringBuilder();
+                        sb2.append("Sending task ");
+                        sb2.append(peek);
+                    }
+                    peek.send(listenerRecord.service);
+                    listenerRecord.taskQueue.remove();
+                } catch (DeadObjectException unused) {
+                    if (Log.isLoggable(NotificationManagerCompat.TAG, 3)) {
+                        StringBuilder sb3 = new StringBuilder();
+                        sb3.append("Remote service has died: ");
+                        sb3.append(listenerRecord.componentName);
+                    }
+                } catch (RemoteException e) {
+                    Log.w(NotificationManagerCompat.TAG, "RemoteException communicating with " + listenerRecord.componentName, e);
+                }
+            }
+            if (listenerRecord.taskQueue.isEmpty()) {
+                return;
+            }
+            scheduleListenerRetry(listenerRecord);
+        }
+
+        public static class ListenerRecord {
+            final ComponentName componentName;
+            INotificationSideChannel service;
+            boolean bound = false;
+            ArrayDeque<Task> taskQueue = new ArrayDeque<>();
+            int retryCount = 0;
+
+            public ListenerRecord(ComponentName componentName) {
+                this.componentName = componentName;
+            }
+        }
+    }
+
+    public static class ServiceConnectedEvent {
+        final ComponentName componentName;
+        final IBinder iBinder;
+
+        public ServiceConnectedEvent(ComponentName componentName, IBinder iBinder) {
+            this.componentName = componentName;
+            this.iBinder = iBinder;
+        }
+    }
+
+    public static class NotifyTask implements Task {
+        final int id;
+        final Notification notif;
+        final String packageName;
+        final String tag;
+
+        public NotifyTask(String str, int i, String str2, Notification notification) {
+            this.packageName = str;
+            this.id = i;
+            this.tag = str2;
+            this.notif = notification;
+        }
+
+        @Override // androidx.core.app.NotificationManagerCompat.Task
+        public void send(INotificationSideChannel iNotificationSideChannel) throws RemoteException {
+            iNotificationSideChannel.notify(this.packageName, this.id, this.tag, this.notif);
+        }
+
+        @NonNull
+        public String toString() {
+            return "NotifyTask[packageName:" + this.packageName + ", id:" + this.id + ", tag:" + this.tag + v8.i.e;
+        }
+    }
+
+    public static class CancelTask implements Task {
+        final boolean all;
+        final int id;
+        final String packageName;
+        final String tag;
+
+        public CancelTask(String str) {
+            this.packageName = str;
+            this.id = 0;
+            this.tag = null;
+            this.all = true;
+        }
+
+        public CancelTask(String str, int i, String str2) {
+            this.packageName = str;
+            this.id = i;
+            this.tag = str2;
+            this.all = false;
+        }
+
+        @Override // androidx.core.app.NotificationManagerCompat.Task
+        public void send(INotificationSideChannel iNotificationSideChannel) throws RemoteException {
+            if (this.all) {
+                iNotificationSideChannel.cancelAll(this.packageName);
+            } else {
+                iNotificationSideChannel.cancel(this.packageName, this.id, this.tag);
+            }
+        }
+
+        @NonNull
+        public String toString() {
+            return "CancelTask[packageName:" + this.packageName + ", id:" + this.id + ", tag:" + this.tag + ", all:" + this.all + v8.i.e;
+        }
+    }
+
+    @RequiresApi(23)
+    public static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        public static List<StatusBarNotification> getActiveNotifications(NotificationManager notificationManager) {
+            StatusBarNotification[] activeNotifications = notificationManager.getActiveNotifications();
+            if (activeNotifications == null) {
+                return new ArrayList();
+            }
+            return Arrays.asList(activeNotifications);
+        }
+
+        public static int getCurrentInterruptionFilter(NotificationManager notificationManager) {
+            return notificationManager.getCurrentInterruptionFilter();
+        }
+    }
+
+    @RequiresApi(24)
+    public static class Api24Impl {
+        private Api24Impl() {
+        }
+
+        public static boolean areNotificationsEnabled(NotificationManager notificationManager) {
+            return notificationManager.areNotificationsEnabled();
+        }
+
+        public static int getImportance(NotificationManager notificationManager) {
+            return notificationManager.getImportance();
+        }
+    }
+
+    @RequiresApi(26)
+    public static class Api26Impl {
+        private Api26Impl() {
+        }
+
+        public static void createNotificationChannel(NotificationManager notificationManager, NotificationChannel notificationChannel) {
+            notificationManager.createNotificationChannel(notificationChannel);
+        }
+
+        public static NotificationChannel getNotificationChannel(NotificationManager notificationManager, String str) {
+            return notificationManager.getNotificationChannel(str);
+        }
+
+        public static void createNotificationChannels(NotificationManager notificationManager, List<NotificationChannel> list) {
+            notificationManager.createNotificationChannels(list);
+        }
+
+        public static List<NotificationChannel> getNotificationChannels(NotificationManager notificationManager) {
+            return notificationManager.getNotificationChannels();
+        }
+
+        public static void createNotificationChannelGroup(NotificationManager notificationManager, NotificationChannelGroup notificationChannelGroup) {
+            notificationManager.createNotificationChannelGroup(notificationChannelGroup);
+        }
+
+        public static void createNotificationChannelGroups(NotificationManager notificationManager, List<NotificationChannelGroup> list) {
+            notificationManager.createNotificationChannelGroups(list);
+        }
+
+        public static List<NotificationChannelGroup> getNotificationChannelGroups(NotificationManager notificationManager) {
+            return notificationManager.getNotificationChannelGroups();
+        }
+
+        public static void deleteNotificationChannel(NotificationManager notificationManager, String str) {
+            notificationManager.deleteNotificationChannel(str);
+        }
+
+        public static void deleteNotificationChannelGroup(NotificationManager notificationManager, String str) {
+            notificationManager.deleteNotificationChannelGroup(str);
+        }
+
+        public static String getId(NotificationChannel notificationChannel) {
+            return notificationChannel.getId();
+        }
+
+        public static String getId(NotificationChannelGroup notificationChannelGroup) {
+            return notificationChannelGroup.getId();
+        }
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static NotificationChannelGroup getNotificationChannelGroup(NotificationManager notificationManager, String str) {
+            return notificationManager.getNotificationChannelGroup(str);
+        }
+    }
+
+    @RequiresApi(30)
+    public static class Api30Impl {
+        private Api30Impl() {
+        }
+
+        public static String getParentChannelId(NotificationChannel notificationChannel) {
+            return notificationChannel.getParentChannelId();
+        }
+
+        public static NotificationChannel getNotificationChannel(NotificationManager notificationManager, String str, String str2) {
+            return notificationManager.getNotificationChannel(str, str2);
+        }
+    }
+
+    @RequiresApi(34)
+    public static class Api34Impl {
+        private Api34Impl() {
+        }
+
+        public static boolean canUseFullScreenIntent(NotificationManager notificationManager) {
+            return notificationManager.canUseFullScreenIntent();
+        }
+    }
+}

decompiled/sources/androidx/core/app/OnMultiWindowModeChangedProvider.java

@@ -0,0 +1,10 @@
+package androidx.core.app;
+
+import androidx.core.util.Consumer;
+
+/* loaded from: classes.dex */
+public interface OnMultiWindowModeChangedProvider {
+    void addOnMultiWindowModeChangedListener(Consumer<MultiWindowModeChangedInfo> consumer);
+
+    void removeOnMultiWindowModeChangedListener(Consumer<MultiWindowModeChangedInfo> consumer);
+}

decompiled/sources/androidx/core/app/OnNewIntentProvider.java

@@ -0,0 +1,11 @@
+package androidx.core.app;
+
+import android.content.Intent;
+import androidx.core.util.Consumer;
+
+/* loaded from: classes.dex */
+public interface OnNewIntentProvider {
+    void addOnNewIntentListener(Consumer<Intent> consumer);
+
+    void removeOnNewIntentListener(Consumer<Intent> consumer);
+}

decompiled/sources/androidx/core/app/OnPictureInPictureModeChangedProvider.java

@@ -0,0 +1,10 @@
+package androidx.core.app;
+
+import androidx.core.util.Consumer;
+
+/* loaded from: classes.dex */
+public interface OnPictureInPictureModeChangedProvider {
+    void addOnPictureInPictureModeChangedListener(Consumer<PictureInPictureModeChangedInfo> consumer);
+
+    void removeOnPictureInPictureModeChangedListener(Consumer<PictureInPictureModeChangedInfo> consumer);
+}

decompiled/sources/androidx/core/app/OnUserLeaveHintProvider.java

@@ -0,0 +1,8 @@
+package androidx.core.app;
+
+/* loaded from: classes.dex */
+public interface OnUserLeaveHintProvider {
+    void addOnUserLeaveHintListener(Runnable runnable);
+
+    void removeOnUserLeaveHintListener(Runnable runnable);
+}

decompiled/sources/androidx/core/app/PendingIntentCompat.java

@@ -0,0 +1,202 @@
+package androidx.core.app;
+
+import android.annotation.SuppressLint;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.core.app.PendingIntentCompat;
+import androidx.core.view.accessibility.AccessibilityEventCompat;
+import java.io.Closeable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.concurrent.CountDownLatch;
+
+/* loaded from: classes.dex */
+public final class PendingIntentCompat {
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public @interface Flags {
+    }
+
+    private static int addMutabilityFlags(boolean z, int i) {
+        int i2;
+        if (!z) {
+            i2 = AccessibilityEventCompat.TYPE_VIEW_TARGETED_BY_SCROLL;
+        } else {
+            if (Build.VERSION.SDK_INT < 31) {
+                return i;
+            }
+            i2 = 33554432;
+        }
+        return i | i2;
+    }
+
+    @NonNull
+    public static PendingIntent getActivities(@NonNull Context context, int i, @NonNull @SuppressLint({"ArrayReturn"}) Intent[] intentArr, int i2, @Nullable Bundle bundle, boolean z) {
+        return PendingIntent.getActivities(context, i, intentArr, addMutabilityFlags(z, i2), bundle);
+    }
+
+    @NonNull
+    public static PendingIntent getActivities(@NonNull Context context, int i, @NonNull @SuppressLint({"ArrayReturn"}) Intent[] intentArr, int i2, boolean z) {
+        return PendingIntent.getActivities(context, i, intentArr, addMutabilityFlags(z, i2));
+    }
+
+    @Nullable
+    public static PendingIntent getActivity(@NonNull Context context, int i, @NonNull Intent intent, int i2, boolean z) {
+        return PendingIntent.getActivity(context, i, intent, addMutabilityFlags(z, i2));
+    }
+
+    @Nullable
+    public static PendingIntent getActivity(@NonNull Context context, int i, @NonNull Intent intent, int i2, @Nullable Bundle bundle, boolean z) {
+        return PendingIntent.getActivity(context, i, intent, addMutabilityFlags(z, i2), bundle);
+    }
+
+    @Nullable
+    public static PendingIntent getBroadcast(@NonNull Context context, int i, @NonNull Intent intent, int i2, boolean z) {
+        return PendingIntent.getBroadcast(context, i, intent, addMutabilityFlags(z, i2));
+    }
+
+    @NonNull
+    @RequiresApi(26)
+    public static PendingIntent getForegroundService(@NonNull Context context, int i, @NonNull Intent intent, int i2, boolean z) {
+        return Api26Impl.getForegroundService(context, i, intent, addMutabilityFlags(z, i2));
+    }
+
+    @Nullable
+    public static PendingIntent getService(@NonNull Context context, int i, @NonNull Intent intent, int i2, boolean z) {
+        return PendingIntent.getService(context, i, intent, addMutabilityFlags(z, i2));
+    }
+
+    @SuppressLint({"LambdaLast"})
+    public static void send(@NonNull PendingIntent pendingIntent, int i, @Nullable PendingIntent.OnFinished onFinished, @Nullable Handler handler) throws PendingIntent.CanceledException {
+        GatedCallback gatedCallback = new GatedCallback(onFinished);
+        try {
+            pendingIntent.send(i, gatedCallback.getCallback(), handler);
+            gatedCallback.complete();
+            gatedCallback.close();
+        } catch (Throwable th) {
+            try {
+                gatedCallback.close();
+            } catch (Throwable th2) {
+                th.addSuppressed(th2);
+            }
+            throw th;
+        }
+    }
+
+    @SuppressLint({"LambdaLast"})
+    public static void send(@NonNull PendingIntent pendingIntent, @NonNull @SuppressLint({"ContextFirst"}) Context context, int i, @NonNull Intent intent, @Nullable PendingIntent.OnFinished onFinished, @Nullable Handler handler) throws PendingIntent.CanceledException {
+        send(pendingIntent, context, i, intent, onFinished, handler, null, null);
+    }
+
+    @SuppressLint({"LambdaLast"})
+    public static void send(@NonNull PendingIntent pendingIntent, @NonNull @SuppressLint({"ContextFirst"}) Context context, int i, @NonNull Intent intent, @Nullable PendingIntent.OnFinished onFinished, @Nullable Handler handler, @Nullable String str, @Nullable Bundle bundle) throws PendingIntent.CanceledException {
+        GatedCallback gatedCallback = new GatedCallback(onFinished);
+        try {
+            Api23Impl.send(pendingIntent, context, i, intent, onFinished, handler, str, bundle);
+            gatedCallback.complete();
+            gatedCallback.close();
+        } catch (Throwable th) {
+            try {
+                gatedCallback.close();
+            } catch (Throwable th2) {
+                th.addSuppressed(th2);
+            }
+            throw th;
+        }
+    }
+
+    private PendingIntentCompat() {
+    }
+
+    @RequiresApi(23)
+    public static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        public static void send(@NonNull PendingIntent pendingIntent, @NonNull Context context, int i, @NonNull Intent intent, @Nullable PendingIntent.OnFinished onFinished, @Nullable Handler handler, @Nullable String str, @Nullable Bundle bundle) throws PendingIntent.CanceledException {
+            pendingIntent.send(context, i, intent, onFinished, handler, str, bundle);
+        }
+    }
+
+    @RequiresApi(26)
+    public static class Api26Impl {
+        private Api26Impl() {
+        }
+
+        public static PendingIntent getForegroundService(Context context, int i, Intent intent, int i2) {
+            return PendingIntent.getForegroundService(context, i, intent, i2);
+        }
+    }
+
+    public static class GatedCallback implements Closeable {
+
+        @Nullable
+        private PendingIntent.OnFinished mCallback;
+        private final CountDownLatch mComplete = new CountDownLatch(1);
+        private boolean mSuccess = false;
+
+        public void complete() {
+            this.mSuccess = true;
+        }
+
+        public GatedCallback(@Nullable PendingIntent.OnFinished onFinished) {
+            this.mCallback = onFinished;
+        }
+
+        @Nullable
+        public PendingIntent.OnFinished getCallback() {
+            if (this.mCallback == null) {
+                return null;
+            }
+            return new PendingIntent.OnFinished() { // from class: androidx.core.app.PendingIntentCompat$GatedCallback$$ExternalSyntheticLambda0
+                @Override // android.app.PendingIntent.OnFinished
+                public final void onSendFinished(PendingIntent pendingIntent, Intent intent, int i, String str, Bundle bundle) {
+                    PendingIntentCompat.GatedCallback.this.onSendFinished(pendingIntent, intent, i, str, bundle);
+                }
+            };
+        }
+
+        @Override // java.io.Closeable, java.lang.AutoCloseable
+        public void close() {
+            if (!this.mSuccess) {
+                this.mCallback = null;
+            }
+            this.mComplete.countDown();
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void onSendFinished(PendingIntent pendingIntent, Intent intent, int i, String str, Bundle bundle) {
+            boolean z = false;
+            while (true) {
+                try {
+                    this.mComplete.await();
+                    break;
+                } catch (InterruptedException unused) {
+                    z = true;
+                } catch (Throwable th) {
+                    if (z) {
+                        Thread.currentThread().interrupt();
+                    }
+                    throw th;
+                }
+            }
+            if (z) {
+                Thread.currentThread().interrupt();
+            }
+            PendingIntent.OnFinished onFinished = this.mCallback;
+            if (onFinished != null) {
+                onFinished.onSendFinished(pendingIntent, intent, i, str, bundle);
+                this.mCallback = null;
+            }
+        }
+    }
+}

decompiled/sources/androidx/core/app/Person.java

@@ -0,0 +1,263 @@
+package androidx.core.app;
+
+import android.app.Person;
+import android.os.Bundle;
+import android.os.PersistableBundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.core.graphics.drawable.IconCompat;
+import java.util.Objects;
+
+/* loaded from: classes.dex */
+public class Person {
+    private static final String ICON_KEY = "icon";
+    private static final String IS_BOT_KEY = "isBot";
+    private static final String IS_IMPORTANT_KEY = "isImportant";
+    private static final String KEY_KEY = "key";
+    private static final String NAME_KEY = "name";
+    private static final String URI_KEY = "uri";
+
+    @Nullable
+    IconCompat mIcon;
+    boolean mIsBot;
+    boolean mIsImportant;
+
+    @Nullable
+    String mKey;
+
+    @Nullable
+    CharSequence mName;
+
+    @Nullable
+    String mUri;
+
+    @Nullable
+    public IconCompat getIcon() {
+        return this.mIcon;
+    }
+
+    @Nullable
+    public String getKey() {
+        return this.mKey;
+    }
+
+    @Nullable
+    public CharSequence getName() {
+        return this.mName;
+    }
+
+    @Nullable
+    public String getUri() {
+        return this.mUri;
+    }
+
+    public boolean isBot() {
+        return this.mIsBot;
+    }
+
+    public boolean isImportant() {
+        return this.mIsImportant;
+    }
+
+    @NonNull
+    public static Person fromBundle(@NonNull Bundle bundle) {
+        Bundle bundle2 = bundle.getBundle("icon");
+        return new Builder().setName(bundle.getCharSequence("name")).setIcon(bundle2 != null ? IconCompat.createFromBundle(bundle2) : null).setUri(bundle.getString("uri")).setKey(bundle.getString("key")).setBot(bundle.getBoolean(IS_BOT_KEY)).setImportant(bundle.getBoolean(IS_IMPORTANT_KEY)).build();
+    }
+
+    @NonNull
+    @RequiresApi(22)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static Person fromPersistableBundle(@NonNull PersistableBundle persistableBundle) {
+        return Api22Impl.fromPersistableBundle(persistableBundle);
+    }
+
+    @NonNull
+    @RequiresApi(28)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static Person fromAndroidPerson(@NonNull android.app.Person person) {
+        return Api28Impl.fromAndroidPerson(person);
+    }
+
+    public Person(Builder builder) {
+        this.mName = builder.mName;
+        this.mIcon = builder.mIcon;
+        this.mUri = builder.mUri;
+        this.mKey = builder.mKey;
+        this.mIsBot = builder.mIsBot;
+        this.mIsImportant = builder.mIsImportant;
+    }
+
+    @NonNull
+    public Bundle toBundle() {
+        Bundle bundle = new Bundle();
+        bundle.putCharSequence("name", this.mName);
+        IconCompat iconCompat = this.mIcon;
+        bundle.putBundle("icon", iconCompat != null ? iconCompat.toBundle() : null);
+        bundle.putString("uri", this.mUri);
+        bundle.putString("key", this.mKey);
+        bundle.putBoolean(IS_BOT_KEY, this.mIsBot);
+        bundle.putBoolean(IS_IMPORTANT_KEY, this.mIsImportant);
+        return bundle;
+    }
+
+    @NonNull
+    @RequiresApi(22)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public PersistableBundle toPersistableBundle() {
+        return Api22Impl.toPersistableBundle(this);
+    }
+
+    @NonNull
+    public Builder toBuilder() {
+        return new Builder(this);
+    }
+
+    @NonNull
+    @RequiresApi(28)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public android.app.Person toAndroidPerson() {
+        return Api28Impl.toAndroidPerson(this);
+    }
+
+    @NonNull
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public String resolveToLegacyUri() {
+        String str = this.mUri;
+        if (str != null) {
+            return str;
+        }
+        if (this.mName == null) {
+            return "";
+        }
+        return "name:" + ((Object) this.mName);
+    }
+
+    public boolean equals(@Nullable Object obj) {
+        if (obj == null || !(obj instanceof Person)) {
+            return false;
+        }
+        Person person = (Person) obj;
+        String key = getKey();
+        String key2 = person.getKey();
+        if (key == null && key2 == null) {
+            return Objects.equals(Objects.toString(getName()), Objects.toString(person.getName())) && Objects.equals(getUri(), person.getUri()) && Objects.equals(Boolean.valueOf(isBot()), Boolean.valueOf(person.isBot())) && Objects.equals(Boolean.valueOf(isImportant()), Boolean.valueOf(person.isImportant()));
+        }
+        return Objects.equals(key, key2);
+    }
+
+    public int hashCode() {
+        String key = getKey();
+        if (key != null) {
+            return key.hashCode();
+        }
+        return Objects.hash(getName(), getUri(), Boolean.valueOf(isBot()), Boolean.valueOf(isImportant()));
+    }
+
+    public static class Builder {
+
+        @Nullable
+        IconCompat mIcon;
+        boolean mIsBot;
+        boolean mIsImportant;
+
+        @Nullable
+        String mKey;
+
+        @Nullable
+        CharSequence mName;
+
+        @Nullable
+        String mUri;
+
+        @NonNull
+        public Builder setBot(boolean z) {
+            this.mIsBot = z;
+            return this;
+        }
+
+        @NonNull
+        public Builder setIcon(@Nullable IconCompat iconCompat) {
+            this.mIcon = iconCompat;
+            return this;
+        }
+
+        @NonNull
+        public Builder setImportant(boolean z) {
+            this.mIsImportant = z;
+            return this;
+        }
+
+        @NonNull
+        public Builder setKey(@Nullable String str) {
+            this.mKey = str;
+            return this;
+        }
+
+        @NonNull
+        public Builder setName(@Nullable CharSequence charSequence) {
+            this.mName = charSequence;
+            return this;
+        }
+
+        @NonNull
+        public Builder setUri(@Nullable String str) {
+            this.mUri = str;
+            return this;
+        }
+
+        public Builder() {
+        }
+
+        public Builder(Person person) {
+            this.mName = person.mName;
+            this.mIcon = person.mIcon;
+            this.mUri = person.mUri;
+            this.mKey = person.mKey;
+            this.mIsBot = person.mIsBot;
+            this.mIsImportant = person.mIsImportant;
+        }
+
+        @NonNull
+        public Person build() {
+            return new Person(this);
+        }
+    }
+
+    @RequiresApi(22)
+    public static class Api22Impl {
+        private Api22Impl() {
+        }
+
+        public static Person fromPersistableBundle(PersistableBundle persistableBundle) {
+            return new Builder().setName(persistableBundle.getString("name")).setUri(persistableBundle.getString("uri")).setKey(persistableBundle.getString("key")).setBot(persistableBundle.getBoolean(Person.IS_BOT_KEY)).setImportant(persistableBundle.getBoolean(Person.IS_IMPORTANT_KEY)).build();
+        }
+
+        public static PersistableBundle toPersistableBundle(Person person) {
+            PersistableBundle persistableBundle = new PersistableBundle();
+            CharSequence charSequence = person.mName;
+            persistableBundle.putString("name", charSequence != null ? charSequence.toString() : null);
+            persistableBundle.putString("uri", person.mUri);
+            persistableBundle.putString("key", person.mKey);
+            persistableBundle.putBoolean(Person.IS_BOT_KEY, person.mIsBot);
+            persistableBundle.putBoolean(Person.IS_IMPORTANT_KEY, person.mIsImportant);
+            return persistableBundle;
+        }
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static Person fromAndroidPerson(android.app.Person person) {
+            return new Builder().setName(person.getName()).setIcon(person.getIcon() != null ? IconCompat.createFromIcon(person.getIcon()) : null).setUri(person.getUri()).setKey(person.getKey()).setBot(person.isBot()).setImportant(person.isImportant()).build();
+        }
+
+        public static android.app.Person toAndroidPerson(Person person) {
+            return new Person.Builder().setName(person.getName()).setIcon(person.getIcon() != null ? person.getIcon().toIcon() : null).setUri(person.getUri()).setKey(person.getKey()).setBot(person.isBot()).setImportant(person.isImportant()).build();
+        }
+    }
+}

decompiled/sources/androidx/core/app/PictureInPictureModeChangedInfo.java

@@ -0,0 +1,38 @@
+package androidx.core.app;
+
+import android.content.res.Configuration;
+import androidx.annotation.RequiresApi;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class PictureInPictureModeChangedInfo {
+    private final boolean isInPictureInPictureMode;
+
+    @RequiresApi(26)
+    private Configuration newConfiguration;
+
+    public final boolean isInPictureInPictureMode() {
+        return this.isInPictureInPictureMode;
+    }
+
+    public PictureInPictureModeChangedInfo(boolean z) {
+        this.isInPictureInPictureMode = z;
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    @RequiresApi(26)
+    public PictureInPictureModeChangedInfo(boolean z, Configuration newConfig) {
+        this(z);
+        Intrinsics.checkNotNullParameter(newConfig, "newConfig");
+        this.newConfiguration = newConfig;
+    }
+
+    @RequiresApi(26)
+    public final Configuration getNewConfig() {
+        Configuration configuration = this.newConfiguration;
+        if (configuration != null) {
+            return configuration;
+        }
+        throw new IllegalStateException("PictureInPictureModeChangedInfo must be constructed with the constructor that takes a Configuration to access the newConfig. Are you running on an API 26 or higher device that makes this information available?".toString());
+    }
+}

decompiled/sources/androidx/core/app/RemoteActionCompat.java

@@ -0,0 +1,170 @@
+package androidx.core.app;
+
+import android.annotation.SuppressLint;
+import android.app.PendingIntent;
+import android.app.RemoteAction;
+import android.graphics.drawable.Icon;
+import android.os.Build;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.core.graphics.drawable.IconCompat;
+import androidx.core.util.Preconditions;
+import androidx.versionedparcelable.VersionedParcelable;
+
+/* loaded from: classes.dex */
+public final class RemoteActionCompat implements VersionedParcelable {
+
+    @NonNull
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public PendingIntent mActionIntent;
+
+    @NonNull
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public CharSequence mContentDescription;
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public boolean mEnabled;
+
+    @NonNull
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public IconCompat mIcon;
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public boolean mShouldShowIcon;
+
+    @NonNull
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public CharSequence mTitle;
+
+    @NonNull
+    public PendingIntent getActionIntent() {
+        return this.mActionIntent;
+    }
+
+    @NonNull
+    public CharSequence getContentDescription() {
+        return this.mContentDescription;
+    }
+
+    @NonNull
+    public IconCompat getIcon() {
+        return this.mIcon;
+    }
+
+    @NonNull
+    public CharSequence getTitle() {
+        return this.mTitle;
+    }
+
+    public boolean isEnabled() {
+        return this.mEnabled;
+    }
+
+    public void setEnabled(boolean z) {
+        this.mEnabled = z;
+    }
+
+    public void setShouldShowIcon(boolean z) {
+        this.mShouldShowIcon = z;
+    }
+
+    @SuppressLint({"KotlinPropertyAccess"})
+    public boolean shouldShowIcon() {
+        return this.mShouldShowIcon;
+    }
+
+    public RemoteActionCompat(@NonNull IconCompat iconCompat, @NonNull CharSequence charSequence, @NonNull CharSequence charSequence2, @NonNull PendingIntent pendingIntent) {
+        this.mIcon = (IconCompat) Preconditions.checkNotNull(iconCompat);
+        this.mTitle = (CharSequence) Preconditions.checkNotNull(charSequence);
+        this.mContentDescription = (CharSequence) Preconditions.checkNotNull(charSequence2);
+        this.mActionIntent = (PendingIntent) Preconditions.checkNotNull(pendingIntent);
+        this.mEnabled = true;
+        this.mShouldShowIcon = true;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+    public RemoteActionCompat() {
+    }
+
+    public RemoteActionCompat(@NonNull RemoteActionCompat remoteActionCompat) {
+        Preconditions.checkNotNull(remoteActionCompat);
+        this.mIcon = remoteActionCompat.mIcon;
+        this.mTitle = remoteActionCompat.mTitle;
+        this.mContentDescription = remoteActionCompat.mContentDescription;
+        this.mActionIntent = remoteActionCompat.mActionIntent;
+        this.mEnabled = remoteActionCompat.mEnabled;
+        this.mShouldShowIcon = remoteActionCompat.mShouldShowIcon;
+    }
+
+    @NonNull
+    @RequiresApi(26)
+    public static RemoteActionCompat createFromRemoteAction(@NonNull RemoteAction remoteAction) {
+        Preconditions.checkNotNull(remoteAction);
+        RemoteActionCompat remoteActionCompat = new RemoteActionCompat(IconCompat.createFromIcon(Api26Impl.getIcon(remoteAction)), Api26Impl.getTitle(remoteAction), Api26Impl.getContentDescription(remoteAction), Api26Impl.getActionIntent(remoteAction));
+        remoteActionCompat.setEnabled(Api26Impl.isEnabled(remoteAction));
+        if (Build.VERSION.SDK_INT >= 28) {
+            remoteActionCompat.setShouldShowIcon(Api28Impl.shouldShowIcon(remoteAction));
+        }
+        return remoteActionCompat;
+    }
+
+    @NonNull
+    @RequiresApi(26)
+    public RemoteAction toRemoteAction() {
+        RemoteAction createRemoteAction = Api26Impl.createRemoteAction(this.mIcon.toIcon(), this.mTitle, this.mContentDescription, this.mActionIntent);
+        Api26Impl.setEnabled(createRemoteAction, isEnabled());
+        if (Build.VERSION.SDK_INT >= 28) {
+            Api28Impl.setShouldShowIcon(createRemoteAction, shouldShowIcon());
+        }
+        return createRemoteAction;
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static boolean shouldShowIcon(RemoteAction remoteAction) {
+            return remoteAction.shouldShowIcon();
+        }
+
+        public static void setShouldShowIcon(RemoteAction remoteAction, boolean z) {
+            remoteAction.setShouldShowIcon(z);
+        }
+    }
+
+    @RequiresApi(26)
+    public static class Api26Impl {
+        private Api26Impl() {
+        }
+
+        public static CharSequence getContentDescription(RemoteAction remoteAction) {
+            return remoteAction.getContentDescription();
+        }
+
+        public static PendingIntent getActionIntent(RemoteAction remoteAction) {
+            return remoteAction.getActionIntent();
+        }
+
+        public static CharSequence getTitle(RemoteAction remoteAction) {
+            return remoteAction.getTitle();
+        }
+
+        public static Icon getIcon(RemoteAction remoteAction) {
+            return remoteAction.getIcon();
+        }
+
+        public static boolean isEnabled(RemoteAction remoteAction) {
+            return remoteAction.isEnabled();
+        }
+
+        public static RemoteAction createRemoteAction(Icon icon, CharSequence charSequence, CharSequence charSequence2, PendingIntent pendingIntent) {
+            return new RemoteAction(icon, charSequence, charSequence2, pendingIntent);
+        }
+
+        public static void setEnabled(RemoteAction remoteAction, boolean z) {
+            remoteAction.setEnabled(z);
+        }
+    }
+}

decompiled/sources/androidx/core/app/RemoteActionCompatParcelizer.java

@@ -0,0 +1,31 @@
+package androidx.core.app;
+
+import android.app.PendingIntent;
+import androidx.annotation.RestrictTo;
+import androidx.core.graphics.drawable.IconCompat;
+import androidx.versionedparcelable.VersionedParcel;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public class RemoteActionCompatParcelizer {
+    public static RemoteActionCompat read(VersionedParcel versionedParcel) {
+        RemoteActionCompat remoteActionCompat = new RemoteActionCompat();
+        remoteActionCompat.mIcon = (IconCompat) versionedParcel.readVersionedParcelable(remoteActionCompat.mIcon, 1);
+        remoteActionCompat.mTitle = versionedParcel.readCharSequence(remoteActionCompat.mTitle, 2);
+        remoteActionCompat.mContentDescription = versionedParcel.readCharSequence(remoteActionCompat.mContentDescription, 3);
+        remoteActionCompat.mActionIntent = (PendingIntent) versionedParcel.readParcelable(remoteActionCompat.mActionIntent, 4);
+        remoteActionCompat.mEnabled = versionedParcel.readBoolean(remoteActionCompat.mEnabled, 5);
+        remoteActionCompat.mShouldShowIcon = versionedParcel.readBoolean(remoteActionCompat.mShouldShowIcon, 6);
+        return remoteActionCompat;
+    }
+
+    public static void write(RemoteActionCompat remoteActionCompat, VersionedParcel versionedParcel) {
+        versionedParcel.setSerializationFlags(false, false);
+        versionedParcel.writeVersionedParcelable(remoteActionCompat.mIcon, 1);
+        versionedParcel.writeCharSequence(remoteActionCompat.mTitle, 2);
+        versionedParcel.writeCharSequence(remoteActionCompat.mContentDescription, 3);
+        versionedParcel.writeParcelable(remoteActionCompat.mActionIntent, 4);
+        versionedParcel.writeBoolean(remoteActionCompat.mEnabled, 5);
+        versionedParcel.writeBoolean(remoteActionCompat.mShouldShowIcon, 6);
+    }
+}

decompiled/sources/androidx/core/app/RemoteInput.java

@@ -0,0 +1,343 @@
+package androidx.core.app;
+
+import android.app.RemoteInput;
+import android.content.ClipData;
+import android.content.ClipDescription;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+public final class RemoteInput {
+    public static final int EDIT_CHOICES_BEFORE_SENDING_AUTO = 0;
+    public static final int EDIT_CHOICES_BEFORE_SENDING_DISABLED = 1;
+    public static final int EDIT_CHOICES_BEFORE_SENDING_ENABLED = 2;
+    private static final String EXTRA_DATA_TYPE_RESULTS_DATA = "android.remoteinput.dataTypeResultsData";
+    public static final String EXTRA_RESULTS_DATA = "android.remoteinput.resultsData";
+    private static final String EXTRA_RESULTS_SOURCE = "android.remoteinput.resultsSource";
+    public static final String RESULTS_CLIP_LABEL = "android.remoteinput.results";
+    public static final int SOURCE_CHOICE = 1;
+    public static final int SOURCE_FREE_FORM_INPUT = 0;
+    private final boolean mAllowFreeFormTextInput;
+    private final Set<String> mAllowedDataTypes;
+    private final CharSequence[] mChoices;
+    private final int mEditChoicesBeforeSending;
+    private final Bundle mExtras;
+    private final CharSequence mLabel;
+    private final String mResultKey;
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public @interface EditChoicesBeforeSending {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public @interface Source {
+    }
+
+    public boolean getAllowFreeFormInput() {
+        return this.mAllowFreeFormTextInput;
+    }
+
+    @Nullable
+    public Set<String> getAllowedDataTypes() {
+        return this.mAllowedDataTypes;
+    }
+
+    @Nullable
+    public CharSequence[] getChoices() {
+        return this.mChoices;
+    }
+
+    public int getEditChoicesBeforeSending() {
+        return this.mEditChoicesBeforeSending;
+    }
+
+    @NonNull
+    public Bundle getExtras() {
+        return this.mExtras;
+    }
+
+    @Nullable
+    public CharSequence getLabel() {
+        return this.mLabel;
+    }
+
+    @NonNull
+    public String getResultKey() {
+        return this.mResultKey;
+    }
+
+    public RemoteInput(String str, CharSequence charSequence, CharSequence[] charSequenceArr, boolean z, int i, Bundle bundle, Set<String> set) {
+        this.mResultKey = str;
+        this.mLabel = charSequence;
+        this.mChoices = charSequenceArr;
+        this.mAllowFreeFormTextInput = z;
+        this.mEditChoicesBeforeSending = i;
+        this.mExtras = bundle;
+        this.mAllowedDataTypes = set;
+        if (getEditChoicesBeforeSending() == 2 && !getAllowFreeFormInput()) {
+            throw new IllegalArgumentException("setEditChoicesBeforeSending requires setAllowFreeFormInput");
+        }
+    }
+
+    public boolean isDataOnly() {
+        return (getAllowFreeFormInput() || (getChoices() != null && getChoices().length != 0) || getAllowedDataTypes() == null || getAllowedDataTypes().isEmpty()) ? false : true;
+    }
+
+    public static final class Builder {
+        private CharSequence[] mChoices;
+        private CharSequence mLabel;
+        private final String mResultKey;
+        private final Set<String> mAllowedDataTypes = new HashSet();
+        private final Bundle mExtras = new Bundle();
+        private boolean mAllowFreeFormTextInput = true;
+        private int mEditChoicesBeforeSending = 0;
+
+        @NonNull
+        public Bundle getExtras() {
+            return this.mExtras;
+        }
+
+        @NonNull
+        public Builder setAllowFreeFormInput(boolean z) {
+            this.mAllowFreeFormTextInput = z;
+            return this;
+        }
+
+        @NonNull
+        public Builder setChoices(@Nullable CharSequence[] charSequenceArr) {
+            this.mChoices = charSequenceArr;
+            return this;
+        }
+
+        @NonNull
+        public Builder setEditChoicesBeforeSending(int i) {
+            this.mEditChoicesBeforeSending = i;
+            return this;
+        }
+
+        @NonNull
+        public Builder setLabel(@Nullable CharSequence charSequence) {
+            this.mLabel = charSequence;
+            return this;
+        }
+
+        public Builder(@NonNull String str) {
+            if (str == null) {
+                throw new IllegalArgumentException("Result key can't be null");
+            }
+            this.mResultKey = str;
+        }
+
+        @NonNull
+        public Builder setAllowDataType(@NonNull String str, boolean z) {
+            if (z) {
+                this.mAllowedDataTypes.add(str);
+            } else {
+                this.mAllowedDataTypes.remove(str);
+            }
+            return this;
+        }
+
+        @NonNull
+        public Builder addExtras(@NonNull Bundle bundle) {
+            if (bundle != null) {
+                this.mExtras.putAll(bundle);
+            }
+            return this;
+        }
+
+        @NonNull
+        public RemoteInput build() {
+            return new RemoteInput(this.mResultKey, this.mLabel, this.mChoices, this.mAllowFreeFormTextInput, this.mEditChoicesBeforeSending, this.mExtras, this.mAllowedDataTypes);
+        }
+    }
+
+    @Nullable
+    public static Map<String, Uri> getDataResultsFromIntent(@NonNull Intent intent, @NonNull String str) {
+        return Api26Impl.getDataResultsFromIntent(intent, str);
+    }
+
+    @Nullable
+    public static Bundle getResultsFromIntent(@NonNull Intent intent) {
+        return Api20Impl.getResultsFromIntent(intent);
+    }
+
+    public static void addResultsToIntent(@NonNull RemoteInput[] remoteInputArr, @NonNull Intent intent, @NonNull Bundle bundle) {
+        Api20Impl.addResultsToIntent(fromCompat(remoteInputArr), intent, bundle);
+    }
+
+    public static void addDataResultToIntent(@NonNull RemoteInput remoteInput, @NonNull Intent intent, @NonNull Map<String, Uri> map) {
+        Api26Impl.addDataResultToIntent(remoteInput, intent, map);
+    }
+
+    public static void setResultsSource(@NonNull Intent intent, int i) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            Api28Impl.setResultsSource(intent, i);
+            return;
+        }
+        Intent clipDataIntentFromIntent = getClipDataIntentFromIntent(intent);
+        if (clipDataIntentFromIntent == null) {
+            clipDataIntentFromIntent = new Intent();
+        }
+        clipDataIntentFromIntent.putExtra(EXTRA_RESULTS_SOURCE, i);
+        intent.setClipData(ClipData.newIntent(RESULTS_CLIP_LABEL, clipDataIntentFromIntent));
+    }
+
+    public static int getResultsSource(@NonNull Intent intent) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.getResultsSource(intent);
+        }
+        Intent clipDataIntentFromIntent = getClipDataIntentFromIntent(intent);
+        if (clipDataIntentFromIntent == null) {
+            return 0;
+        }
+        return clipDataIntentFromIntent.getExtras().getInt(EXTRA_RESULTS_SOURCE, 0);
+    }
+
+    private static String getExtraResultsKeyForData(String str) {
+        return EXTRA_DATA_TYPE_RESULTS_DATA + str;
+    }
+
+    @RequiresApi(20)
+    public static android.app.RemoteInput[] fromCompat(RemoteInput[] remoteInputArr) {
+        if (remoteInputArr == null) {
+            return null;
+        }
+        android.app.RemoteInput[] remoteInputArr2 = new android.app.RemoteInput[remoteInputArr.length];
+        for (int i = 0; i < remoteInputArr.length; i++) {
+            remoteInputArr2[i] = fromCompat(remoteInputArr[i]);
+        }
+        return remoteInputArr2;
+    }
+
+    @RequiresApi(20)
+    public static android.app.RemoteInput fromCompat(RemoteInput remoteInput) {
+        return Api20Impl.fromCompat(remoteInput);
+    }
+
+    @RequiresApi(20)
+    public static RemoteInput fromPlatform(android.app.RemoteInput remoteInput) {
+        return Api20Impl.fromPlatform(remoteInput);
+    }
+
+    private static Intent getClipDataIntentFromIntent(Intent intent) {
+        ClipData clipData = intent.getClipData();
+        if (clipData == null) {
+            return null;
+        }
+        ClipDescription description = clipData.getDescription();
+        if (description.hasMimeType("text/vnd.android.intent") && description.getLabel().toString().contentEquals(RESULTS_CLIP_LABEL)) {
+            return clipData.getItemAt(0).getIntent();
+        }
+        return null;
+    }
+
+    @RequiresApi(26)
+    public static class Api26Impl {
+        private Api26Impl() {
+        }
+
+        public static Map<String, Uri> getDataResultsFromIntent(Intent intent, String str) {
+            return android.app.RemoteInput.getDataResultsFromIntent(intent, str);
+        }
+
+        public static Set<String> getAllowedDataTypes(Object obj) {
+            return ((android.app.RemoteInput) obj).getAllowedDataTypes();
+        }
+
+        public static void addDataResultToIntent(RemoteInput remoteInput, Intent intent, Map<String, Uri> map) {
+            android.app.RemoteInput.addDataResultToIntent(RemoteInput.fromCompat(remoteInput), intent, map);
+        }
+
+        public static RemoteInput.Builder setAllowDataType(RemoteInput.Builder builder, String str, boolean z) {
+            return builder.setAllowDataType(str, z);
+        }
+    }
+
+    @RequiresApi(20)
+    public static class Api20Impl {
+        private Api20Impl() {
+        }
+
+        public static Bundle getResultsFromIntent(Intent intent) {
+            return android.app.RemoteInput.getResultsFromIntent(intent);
+        }
+
+        public static void addResultsToIntent(Object obj, Intent intent, Bundle bundle) {
+            android.app.RemoteInput.addResultsToIntent((android.app.RemoteInput[]) obj, intent, bundle);
+        }
+
+        public static RemoteInput fromPlatform(Object obj) {
+            android.app.RemoteInput remoteInput = (android.app.RemoteInput) obj;
+            Builder addExtras = new Builder(remoteInput.getResultKey()).setLabel(remoteInput.getLabel()).setChoices(remoteInput.getChoices()).setAllowFreeFormInput(remoteInput.getAllowFreeFormInput()).addExtras(remoteInput.getExtras());
+            Set<String> allowedDataTypes = Api26Impl.getAllowedDataTypes(remoteInput);
+            if (allowedDataTypes != null) {
+                Iterator<String> it = allowedDataTypes.iterator();
+                while (it.hasNext()) {
+                    addExtras.setAllowDataType(it.next(), true);
+                }
+            }
+            if (Build.VERSION.SDK_INT >= 29) {
+                addExtras.setEditChoicesBeforeSending(Api29Impl.getEditChoicesBeforeSending(remoteInput));
+            }
+            return addExtras.build();
+        }
+
+        public static android.app.RemoteInput fromCompat(RemoteInput remoteInput) {
+            RemoteInput.Builder addExtras = new RemoteInput.Builder(remoteInput.getResultKey()).setLabel(remoteInput.getLabel()).setChoices(remoteInput.getChoices()).setAllowFreeFormInput(remoteInput.getAllowFreeFormInput()).addExtras(remoteInput.getExtras());
+            Set<String> allowedDataTypes = remoteInput.getAllowedDataTypes();
+            if (allowedDataTypes != null) {
+                Iterator<String> it = allowedDataTypes.iterator();
+                while (it.hasNext()) {
+                    Api26Impl.setAllowDataType(addExtras, it.next(), true);
+                }
+            }
+            if (Build.VERSION.SDK_INT >= 29) {
+                Api29Impl.setEditChoicesBeforeSending(addExtras, remoteInput.getEditChoicesBeforeSending());
+            }
+            return addExtras.build();
+        }
+    }
+
+    @RequiresApi(29)
+    public static class Api29Impl {
+        private Api29Impl() {
+        }
+
+        public static int getEditChoicesBeforeSending(Object obj) {
+            return ((android.app.RemoteInput) obj).getEditChoicesBeforeSending();
+        }
+
+        public static RemoteInput.Builder setEditChoicesBeforeSending(RemoteInput.Builder builder, int i) {
+            return builder.setEditChoicesBeforeSending(i);
+        }
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static void setResultsSource(Intent intent, int i) {
+            android.app.RemoteInput.setResultsSource(intent, i);
+        }
+
+        public static int getResultsSource(Intent intent) {
+            return android.app.RemoteInput.getResultsSource(intent);
+        }
+    }
+}

decompiled/sources/androidx/core/app/ServiceCompat.java

@@ -0,0 +1,80 @@
+package androidx.core.app;
+
+import android.app.Notification;
+import android.app.Service;
+import android.os.Build;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes.dex */
+public final class ServiceCompat {
+    private static final int FOREGROUND_SERVICE_TYPE_ALLOWED_SINCE_Q = 255;
+    private static final int FOREGROUND_SERVICE_TYPE_ALLOWED_SINCE_U = 1073745919;
+    public static final int START_STICKY = 1;
+    public static final int STOP_FOREGROUND_DETACH = 2;
+    public static final int STOP_FOREGROUND_REMOVE = 1;
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public @interface StopForegroundFlags {
+    }
+
+    private ServiceCompat() {
+    }
+
+    public static void startForeground(@NonNull Service service, int i, @NonNull Notification notification, int i2) {
+        int i3 = Build.VERSION.SDK_INT;
+        if (i3 >= 34) {
+            Api34Impl.startForeground(service, i, notification, i2);
+        } else if (i3 >= 29) {
+            Api29Impl.startForeground(service, i, notification, i2);
+        } else {
+            service.startForeground(i, notification);
+        }
+    }
+
+    public static void stopForeground(@NonNull Service service, int i) {
+        Api24Impl.stopForeground(service, i);
+    }
+
+    @RequiresApi(24)
+    public static class Api24Impl {
+        private Api24Impl() {
+        }
+
+        public static void stopForeground(Service service, int i) {
+            service.stopForeground(i);
+        }
+    }
+
+    @RequiresApi(29)
+    public static class Api29Impl {
+        private Api29Impl() {
+        }
+
+        public static void startForeground(Service service, int i, Notification notification, int i2) {
+            if (i2 == 0 || i2 == -1) {
+                service.startForeground(i, notification, i2);
+            } else {
+                service.startForeground(i, notification, i2 & 255);
+            }
+        }
+    }
+
+    @RequiresApi(34)
+    public static class Api34Impl {
+        private Api34Impl() {
+        }
+
+        public static void startForeground(Service service, int i, Notification notification, int i2) {
+            if (i2 == 0 || i2 == -1) {
+                service.startForeground(i, notification, i2);
+            } else {
+                service.startForeground(i, notification, i2 & ServiceCompat.FOREGROUND_SERVICE_TYPE_ALLOWED_SINCE_U);
+            }
+        }
+    }
+}

decompiled/sources/androidx/core/app/ShareCompat.java

@@ -0,0 +1,523 @@
+package androidx.core.app;
+
+import android.app.Activity;
+import android.content.ClipData;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.text.Html;
+import android.text.Spanned;
+import android.util.Log;
+import android.view.ActionProvider;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.widget.ShareActionProvider;
+import androidx.annotation.IdRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.StringRes;
+import androidx.core.content.IntentCompat;
+import androidx.core.util.Preconditions;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+public final class ShareCompat {
+    public static final String EXTRA_CALLING_ACTIVITY = "androidx.core.app.EXTRA_CALLING_ACTIVITY";
+    public static final String EXTRA_CALLING_ACTIVITY_INTEROP = "android.support.v4.app.EXTRA_CALLING_ACTIVITY";
+    public static final String EXTRA_CALLING_PACKAGE = "androidx.core.app.EXTRA_CALLING_PACKAGE";
+    public static final String EXTRA_CALLING_PACKAGE_INTEROP = "android.support.v4.app.EXTRA_CALLING_PACKAGE";
+    private static final String HISTORY_FILENAME_PREFIX = ".sharecompat_";
+
+    private ShareCompat() {
+    }
+
+    @Nullable
+    public static String getCallingPackage(@NonNull Activity activity) {
+        Intent intent = activity.getIntent();
+        String callingPackage = activity.getCallingPackage();
+        return (callingPackage != null || intent == null) ? callingPackage : getCallingPackage(intent);
+    }
+
+    @Nullable
+    public static String getCallingPackage(@NonNull Intent intent) {
+        String stringExtra = intent.getStringExtra(EXTRA_CALLING_PACKAGE);
+        return stringExtra == null ? intent.getStringExtra(EXTRA_CALLING_PACKAGE_INTEROP) : stringExtra;
+    }
+
+    @Nullable
+    public static ComponentName getCallingActivity(@NonNull Activity activity) {
+        Intent intent = activity.getIntent();
+        ComponentName callingActivity = activity.getCallingActivity();
+        return callingActivity == null ? getCallingActivity(intent) : callingActivity;
+    }
+
+    @Nullable
+    public static ComponentName getCallingActivity(@NonNull Intent intent) {
+        ComponentName componentName = (ComponentName) intent.getParcelableExtra(EXTRA_CALLING_ACTIVITY);
+        return componentName == null ? (ComponentName) intent.getParcelableExtra(EXTRA_CALLING_ACTIVITY_INTEROP) : componentName;
+    }
+
+    @Deprecated
+    public static void configureMenuItem(@NonNull MenuItem menuItem, @NonNull IntentBuilder intentBuilder) {
+        ShareActionProvider shareActionProvider;
+        ActionProvider actionProvider = menuItem.getActionProvider();
+        if (!(actionProvider instanceof ShareActionProvider)) {
+            shareActionProvider = new ShareActionProvider(intentBuilder.getContext());
+        } else {
+            shareActionProvider = (ShareActionProvider) actionProvider;
+        }
+        shareActionProvider.setShareHistoryFileName(HISTORY_FILENAME_PREFIX + intentBuilder.getContext().getClass().getName());
+        shareActionProvider.setShareIntent(intentBuilder.getIntent());
+        menuItem.setActionProvider(shareActionProvider);
+    }
+
+    @Deprecated
+    public static void configureMenuItem(@NonNull Menu menu, @IdRes int i, @NonNull IntentBuilder intentBuilder) {
+        MenuItem findItem = menu.findItem(i);
+        if (findItem == null) {
+            throw new IllegalArgumentException("Could not find menu item with id " + i + " in the supplied menu");
+        }
+        configureMenuItem(findItem, intentBuilder);
+    }
+
+    public static class IntentBuilder {
+
+        @Nullable
+        private ArrayList<String> mBccAddresses;
+
+        @Nullable
+        private ArrayList<String> mCcAddresses;
+
+        @Nullable
+        private CharSequence mChooserTitle;
+
+        @NonNull
+        private final Context mContext;
+
+        @NonNull
+        private final Intent mIntent;
+
+        @Nullable
+        private ArrayList<Uri> mStreams;
+
+        @Nullable
+        private ArrayList<String> mToAddresses;
+
+        @NonNull
+        public Context getContext() {
+            return this.mContext;
+        }
+
+        @NonNull
+        public IntentBuilder setChooserTitle(@Nullable CharSequence charSequence) {
+            this.mChooserTitle = charSequence;
+            return this;
+        }
+
+        @NonNull
+        @Deprecated
+        public static IntentBuilder from(@NonNull Activity activity) {
+            return new IntentBuilder(activity);
+        }
+
+        public IntentBuilder(@NonNull Context context) {
+            Activity activity;
+            this.mContext = (Context) Preconditions.checkNotNull(context);
+            Intent action = new Intent().setAction("android.intent.action.SEND");
+            this.mIntent = action;
+            action.putExtra(ShareCompat.EXTRA_CALLING_PACKAGE, context.getPackageName());
+            action.putExtra(ShareCompat.EXTRA_CALLING_PACKAGE_INTEROP, context.getPackageName());
+            action.addFlags(524288);
+            while (true) {
+                if (!(context instanceof ContextWrapper)) {
+                    activity = null;
+                    break;
+                } else {
+                    if (context instanceof Activity) {
+                        activity = (Activity) context;
+                        break;
+                    }
+                    context = ((ContextWrapper) context).getBaseContext();
+                }
+            }
+            if (activity != null) {
+                ComponentName componentName = activity.getComponentName();
+                this.mIntent.putExtra(ShareCompat.EXTRA_CALLING_ACTIVITY, componentName);
+                this.mIntent.putExtra(ShareCompat.EXTRA_CALLING_ACTIVITY_INTEROP, componentName);
+            }
+        }
+
+        @NonNull
+        public Intent getIntent() {
+            ArrayList<String> arrayList = this.mToAddresses;
+            if (arrayList != null) {
+                combineArrayExtra("android.intent.extra.EMAIL", arrayList);
+                this.mToAddresses = null;
+            }
+            ArrayList<String> arrayList2 = this.mCcAddresses;
+            if (arrayList2 != null) {
+                combineArrayExtra("android.intent.extra.CC", arrayList2);
+                this.mCcAddresses = null;
+            }
+            ArrayList<String> arrayList3 = this.mBccAddresses;
+            if (arrayList3 != null) {
+                combineArrayExtra("android.intent.extra.BCC", arrayList3);
+                this.mBccAddresses = null;
+            }
+            ArrayList<Uri> arrayList4 = this.mStreams;
+            if (arrayList4 == null || arrayList4.size() <= 1) {
+                this.mIntent.setAction("android.intent.action.SEND");
+                ArrayList<Uri> arrayList5 = this.mStreams;
+                if (arrayList5 != null && !arrayList5.isEmpty()) {
+                    this.mIntent.putExtra("android.intent.extra.STREAM", this.mStreams.get(0));
+                    ShareCompat.migrateExtraStreamToClipData(this.mIntent, this.mStreams);
+                } else {
+                    this.mIntent.removeExtra("android.intent.extra.STREAM");
+                    this.mIntent.setClipData(null);
+                    Intent intent = this.mIntent;
+                    intent.setFlags(intent.getFlags() & (-2));
+                }
+            } else {
+                this.mIntent.setAction("android.intent.action.SEND_MULTIPLE");
+                this.mIntent.putParcelableArrayListExtra("android.intent.extra.STREAM", this.mStreams);
+                ShareCompat.migrateExtraStreamToClipData(this.mIntent, this.mStreams);
+            }
+            return this.mIntent;
+        }
+
+        private void combineArrayExtra(String str, ArrayList<String> arrayList) {
+            String[] stringArrayExtra = this.mIntent.getStringArrayExtra(str);
+            int length = stringArrayExtra != null ? stringArrayExtra.length : 0;
+            String[] strArr = new String[arrayList.size() + length];
+            arrayList.toArray(strArr);
+            if (stringArrayExtra != null) {
+                System.arraycopy(stringArrayExtra, 0, strArr, arrayList.size(), length);
+            }
+            this.mIntent.putExtra(str, strArr);
+        }
+
+        private void combineArrayExtra(@Nullable String str, @NonNull String[] strArr) {
+            Intent intent = getIntent();
+            String[] stringArrayExtra = intent.getStringArrayExtra(str);
+            int length = stringArrayExtra != null ? stringArrayExtra.length : 0;
+            String[] strArr2 = new String[strArr.length + length];
+            if (stringArrayExtra != null) {
+                System.arraycopy(stringArrayExtra, 0, strArr2, 0, length);
+            }
+            System.arraycopy(strArr, 0, strArr2, length, strArr.length);
+            intent.putExtra(str, strArr2);
+        }
+
+        @NonNull
+        public Intent createChooserIntent() {
+            return Intent.createChooser(getIntent(), this.mChooserTitle);
+        }
+
+        public void startChooser() {
+            this.mContext.startActivity(createChooserIntent());
+        }
+
+        @NonNull
+        public IntentBuilder setChooserTitle(@StringRes int i) {
+            return setChooserTitle(this.mContext.getText(i));
+        }
+
+        @NonNull
+        public IntentBuilder setType(@Nullable String str) {
+            this.mIntent.setType(str);
+            return this;
+        }
+
+        @NonNull
+        public IntentBuilder setText(@Nullable CharSequence charSequence) {
+            this.mIntent.putExtra("android.intent.extra.TEXT", charSequence);
+            return this;
+        }
+
+        @NonNull
+        public IntentBuilder setHtmlText(@Nullable String str) {
+            this.mIntent.putExtra(IntentCompat.EXTRA_HTML_TEXT, str);
+            if (!this.mIntent.hasExtra("android.intent.extra.TEXT")) {
+                setText(Html.fromHtml(str));
+            }
+            return this;
+        }
+
+        @NonNull
+        public IntentBuilder setStream(@Nullable Uri uri) {
+            this.mStreams = null;
+            if (uri != null) {
+                addStream(uri);
+            }
+            return this;
+        }
+
+        @NonNull
+        public IntentBuilder addStream(@NonNull Uri uri) {
+            if (this.mStreams == null) {
+                this.mStreams = new ArrayList<>();
+            }
+            this.mStreams.add(uri);
+            return this;
+        }
+
+        @NonNull
+        public IntentBuilder setEmailTo(@Nullable String[] strArr) {
+            if (this.mToAddresses != null) {
+                this.mToAddresses = null;
+            }
+            this.mIntent.putExtra("android.intent.extra.EMAIL", strArr);
+            return this;
+        }
+
+        @NonNull
+        public IntentBuilder addEmailTo(@NonNull String str) {
+            if (this.mToAddresses == null) {
+                this.mToAddresses = new ArrayList<>();
+            }
+            this.mToAddresses.add(str);
+            return this;
+        }
+
+        @NonNull
+        public IntentBuilder addEmailTo(@NonNull String[] strArr) {
+            combineArrayExtra("android.intent.extra.EMAIL", strArr);
+            return this;
+        }
+
+        @NonNull
+        public IntentBuilder setEmailCc(@Nullable String[] strArr) {
+            this.mIntent.putExtra("android.intent.extra.CC", strArr);
+            return this;
+        }
+
+        @NonNull
+        public IntentBuilder addEmailCc(@NonNull String str) {
+            if (this.mCcAddresses == null) {
+                this.mCcAddresses = new ArrayList<>();
+            }
+            this.mCcAddresses.add(str);
+            return this;
+        }
+
+        @NonNull
+        public IntentBuilder addEmailCc(@NonNull String[] strArr) {
+            combineArrayExtra("android.intent.extra.CC", strArr);
+            return this;
+        }
+
+        @NonNull
+        public IntentBuilder setEmailBcc(@Nullable String[] strArr) {
+            this.mIntent.putExtra("android.intent.extra.BCC", strArr);
+            return this;
+        }
+
+        @NonNull
+        public IntentBuilder addEmailBcc(@NonNull String str) {
+            if (this.mBccAddresses == null) {
+                this.mBccAddresses = new ArrayList<>();
+            }
+            this.mBccAddresses.add(str);
+            return this;
+        }
+
+        @NonNull
+        public IntentBuilder addEmailBcc(@NonNull String[] strArr) {
+            combineArrayExtra("android.intent.extra.BCC", strArr);
+            return this;
+        }
+
+        @NonNull
+        public IntentBuilder setSubject(@Nullable String str) {
+            this.mIntent.putExtra("android.intent.extra.SUBJECT", str);
+            return this;
+        }
+    }
+
+    public static class IntentReader {
+        private static final String TAG = "IntentReader";
+
+        @Nullable
+        private final ComponentName mCallingActivity;
+
+        @Nullable
+        private final String mCallingPackage;
+
+        @NonNull
+        private final Context mContext;
+
+        @NonNull
+        private final Intent mIntent;
+
+        @Nullable
+        private ArrayList<Uri> mStreams;
+
+        @Nullable
+        public ComponentName getCallingActivity() {
+            return this.mCallingActivity;
+        }
+
+        @Nullable
+        public String getCallingPackage() {
+            return this.mCallingPackage;
+        }
+
+        @NonNull
+        @Deprecated
+        public static IntentReader from(@NonNull Activity activity) {
+            return new IntentReader(activity);
+        }
+
+        public IntentReader(@NonNull Activity activity) {
+            this((Context) Preconditions.checkNotNull(activity), activity.getIntent());
+        }
+
+        public IntentReader(@NonNull Context context, @NonNull Intent intent) {
+            this.mContext = (Context) Preconditions.checkNotNull(context);
+            this.mIntent = (Intent) Preconditions.checkNotNull(intent);
+            this.mCallingPackage = ShareCompat.getCallingPackage(intent);
+            this.mCallingActivity = ShareCompat.getCallingActivity(intent);
+        }
+
+        public boolean isShareIntent() {
+            String action = this.mIntent.getAction();
+            return "android.intent.action.SEND".equals(action) || "android.intent.action.SEND_MULTIPLE".equals(action);
+        }
+
+        public boolean isSingleShare() {
+            return "android.intent.action.SEND".equals(this.mIntent.getAction());
+        }
+
+        public boolean isMultipleShare() {
+            return "android.intent.action.SEND_MULTIPLE".equals(this.mIntent.getAction());
+        }
+
+        @Nullable
+        public String getType() {
+            return this.mIntent.getType();
+        }
+
+        @Nullable
+        public CharSequence getText() {
+            return this.mIntent.getCharSequenceExtra("android.intent.extra.TEXT");
+        }
+
+        @Nullable
+        public String getHtmlText() {
+            String stringExtra = this.mIntent.getStringExtra(IntentCompat.EXTRA_HTML_TEXT);
+            if (stringExtra != null) {
+                return stringExtra;
+            }
+            CharSequence text = getText();
+            if (text instanceof Spanned) {
+                return Html.toHtml((Spanned) text);
+            }
+            return text != null ? Html.escapeHtml(text) : stringExtra;
+        }
+
+        @Nullable
+        public Uri getStream() {
+            return (Uri) this.mIntent.getParcelableExtra("android.intent.extra.STREAM");
+        }
+
+        @Nullable
+        public Uri getStream(int i) {
+            if (this.mStreams == null && isMultipleShare()) {
+                this.mStreams = this.mIntent.getParcelableArrayListExtra("android.intent.extra.STREAM");
+            }
+            ArrayList<Uri> arrayList = this.mStreams;
+            if (arrayList != null) {
+                return arrayList.get(i);
+            }
+            if (i == 0) {
+                return (Uri) this.mIntent.getParcelableExtra("android.intent.extra.STREAM");
+            }
+            throw new IndexOutOfBoundsException("Stream items available: " + getStreamCount() + " index requested: " + i);
+        }
+
+        public int getStreamCount() {
+            if (this.mStreams == null && isMultipleShare()) {
+                this.mStreams = this.mIntent.getParcelableArrayListExtra("android.intent.extra.STREAM");
+            }
+            ArrayList<Uri> arrayList = this.mStreams;
+            if (arrayList != null) {
+                return arrayList.size();
+            }
+            return this.mIntent.hasExtra("android.intent.extra.STREAM") ? 1 : 0;
+        }
+
+        @Nullable
+        public String[] getEmailTo() {
+            return this.mIntent.getStringArrayExtra("android.intent.extra.EMAIL");
+        }
+
+        @Nullable
+        public String[] getEmailCc() {
+            return this.mIntent.getStringArrayExtra("android.intent.extra.CC");
+        }
+
+        @Nullable
+        public String[] getEmailBcc() {
+            return this.mIntent.getStringArrayExtra("android.intent.extra.BCC");
+        }
+
+        @Nullable
+        public String getSubject() {
+            return this.mIntent.getStringExtra("android.intent.extra.SUBJECT");
+        }
+
+        @Nullable
+        public Drawable getCallingActivityIcon() {
+            if (this.mCallingActivity == null) {
+                return null;
+            }
+            try {
+                return this.mContext.getPackageManager().getActivityIcon(this.mCallingActivity);
+            } catch (PackageManager.NameNotFoundException e) {
+                Log.e(TAG, "Could not retrieve icon for calling activity", e);
+                return null;
+            }
+        }
+
+        @Nullable
+        public Drawable getCallingApplicationIcon() {
+            if (this.mCallingPackage == null) {
+                return null;
+            }
+            try {
+                return this.mContext.getPackageManager().getApplicationIcon(this.mCallingPackage);
+            } catch (PackageManager.NameNotFoundException e) {
+                Log.e(TAG, "Could not retrieve icon for calling application", e);
+                return null;
+            }
+        }
+
+        @Nullable
+        public CharSequence getCallingApplicationLabel() {
+            if (this.mCallingPackage == null) {
+                return null;
+            }
+            PackageManager packageManager = this.mContext.getPackageManager();
+            try {
+                return packageManager.getApplicationLabel(packageManager.getApplicationInfo(this.mCallingPackage, 0));
+            } catch (PackageManager.NameNotFoundException e) {
+                Log.e(TAG, "Could not retrieve label for calling application", e);
+                return null;
+            }
+        }
+    }
+
+    public static void migrateExtraStreamToClipData(@NonNull Intent intent, @NonNull ArrayList<Uri> arrayList) {
+        ClipData clipData = new ClipData(null, new String[]{intent.getType()}, new ClipData.Item(intent.getCharSequenceExtra("android.intent.extra.TEXT"), intent.getStringExtra(IntentCompat.EXTRA_HTML_TEXT), null, arrayList.get(0)));
+        int size = arrayList.size();
+        for (int i = 1; i < size; i++) {
+            clipData.addItem(new ClipData.Item(arrayList.get(i)));
+        }
+        intent.setClipData(clipData);
+        intent.addFlags(1);
+    }
+}

decompiled/sources/androidx/core/app/SharedElementCallback.java

@@ -0,0 +1,136 @@
+package androidx.core.app;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Matrix;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.view.View;
+import android.widget.ImageView;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public abstract class SharedElementCallback {
+    private static final String BUNDLE_SNAPSHOT_BITMAP = "sharedElement:snapshot:bitmap";
+    private static final String BUNDLE_SNAPSHOT_IMAGE_MATRIX = "sharedElement:snapshot:imageMatrix";
+    private static final String BUNDLE_SNAPSHOT_IMAGE_SCALETYPE = "sharedElement:snapshot:imageScaleType";
+    private static final int MAX_IMAGE_SIZE = 1048576;
+    private Matrix mTempMatrix;
+
+    public interface OnSharedElementsReadyListener {
+        void onSharedElementsReady();
+    }
+
+    public void onMapSharedElements(List<String> list, Map<String, View> map) {
+    }
+
+    public void onRejectSharedElements(List<View> list) {
+    }
+
+    public void onSharedElementEnd(List<String> list, List<View> list2, List<View> list3) {
+    }
+
+    public void onSharedElementStart(List<String> list, List<View> list2, List<View> list3) {
+    }
+
+    public Parcelable onCaptureSharedElementSnapshot(View view, Matrix matrix, RectF rectF) {
+        Bitmap createDrawableBitmap;
+        if (view instanceof ImageView) {
+            ImageView imageView = (ImageView) view;
+            Drawable drawable = imageView.getDrawable();
+            Drawable background = imageView.getBackground();
+            if (drawable != null && background == null && (createDrawableBitmap = createDrawableBitmap(drawable)) != null) {
+                Bundle bundle = new Bundle();
+                bundle.putParcelable(BUNDLE_SNAPSHOT_BITMAP, createDrawableBitmap);
+                bundle.putString(BUNDLE_SNAPSHOT_IMAGE_SCALETYPE, imageView.getScaleType().toString());
+                if (imageView.getScaleType() == ImageView.ScaleType.MATRIX) {
+                    float[] fArr = new float[9];
+                    imageView.getImageMatrix().getValues(fArr);
+                    bundle.putFloatArray(BUNDLE_SNAPSHOT_IMAGE_MATRIX, fArr);
+                }
+                return bundle;
+            }
+        }
+        int round = Math.round(rectF.width());
+        int round2 = Math.round(rectF.height());
+        if (round <= 0 || round2 <= 0) {
+            return null;
+        }
+        float min = Math.min(1.0f, 1048576.0f / (round * round2));
+        int i = (int) (round * min);
+        int i2 = (int) (round2 * min);
+        if (this.mTempMatrix == null) {
+            this.mTempMatrix = new Matrix();
+        }
+        this.mTempMatrix.set(matrix);
+        this.mTempMatrix.postTranslate(-rectF.left, -rectF.top);
+        this.mTempMatrix.postScale(min, min);
+        Bitmap createBitmap = Bitmap.createBitmap(i, i2, Bitmap.Config.ARGB_8888);
+        Canvas canvas = new Canvas(createBitmap);
+        canvas.concat(this.mTempMatrix);
+        view.draw(canvas);
+        return createBitmap;
+    }
+
+    private static Bitmap createDrawableBitmap(Drawable drawable) {
+        int intrinsicWidth = drawable.getIntrinsicWidth();
+        int intrinsicHeight = drawable.getIntrinsicHeight();
+        if (intrinsicWidth <= 0 || intrinsicHeight <= 0) {
+            return null;
+        }
+        float min = Math.min(1.0f, 1048576.0f / (intrinsicWidth * intrinsicHeight));
+        if ((drawable instanceof BitmapDrawable) && min == 1.0f) {
+            return ((BitmapDrawable) drawable).getBitmap();
+        }
+        int i = (int) (intrinsicWidth * min);
+        int i2 = (int) (intrinsicHeight * min);
+        Bitmap createBitmap = Bitmap.createBitmap(i, i2, Bitmap.Config.ARGB_8888);
+        Canvas canvas = new Canvas(createBitmap);
+        Rect bounds = drawable.getBounds();
+        int i3 = bounds.left;
+        int i4 = bounds.top;
+        int i5 = bounds.right;
+        int i6 = bounds.bottom;
+        drawable.setBounds(0, 0, i, i2);
+        drawable.draw(canvas);
+        drawable.setBounds(i3, i4, i5, i6);
+        return createBitmap;
+    }
+
+    public View onCreateSnapshotView(Context context, Parcelable parcelable) {
+        if (parcelable instanceof Bundle) {
+            Bundle bundle = (Bundle) parcelable;
+            Bitmap bitmap = (Bitmap) bundle.getParcelable(BUNDLE_SNAPSHOT_BITMAP);
+            if (bitmap == null) {
+                return null;
+            }
+            ImageView imageView = new ImageView(context);
+            imageView.setImageBitmap(bitmap);
+            imageView.setScaleType(ImageView.ScaleType.valueOf(bundle.getString(BUNDLE_SNAPSHOT_IMAGE_SCALETYPE)));
+            if (imageView.getScaleType() != ImageView.ScaleType.MATRIX) {
+                return imageView;
+            }
+            float[] floatArray = bundle.getFloatArray(BUNDLE_SNAPSHOT_IMAGE_MATRIX);
+            Matrix matrix = new Matrix();
+            matrix.setValues(floatArray);
+            imageView.setImageMatrix(matrix);
+            return imageView;
+        }
+        if (!(parcelable instanceof Bitmap)) {
+            return null;
+        }
+        ImageView imageView2 = new ImageView(context);
+        imageView2.setImageBitmap((Bitmap) parcelable);
+        return imageView2;
+    }
+
+    public void onSharedElementsArrived(List<String> list, List<View> list2, OnSharedElementsReadyListener onSharedElementsReadyListener) {
+        onSharedElementsReadyListener.onSharedElementsReady();
+    }
+}

decompiled/sources/androidx/core/app/TaskStackBuilder.java

@@ -0,0 +1,168 @@
+package androidx.core.app;
+
+import android.app.Activity;
+import android.app.PendingIntent;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.content.ContextCompat;
+import com.google.android.gms.drive.DriveFile;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public final class TaskStackBuilder implements Iterable<Intent> {
+    private static final String TAG = "TaskStackBuilder";
+    private final ArrayList<Intent> mIntents = new ArrayList<>();
+    private final Context mSourceContext;
+
+    public interface SupportParentable {
+        @Nullable
+        Intent getSupportParentActivityIntent();
+    }
+
+    private TaskStackBuilder(Context context) {
+        this.mSourceContext = context;
+    }
+
+    @NonNull
+    public static TaskStackBuilder create(@NonNull Context context) {
+        return new TaskStackBuilder(context);
+    }
+
+    @Deprecated
+    public static TaskStackBuilder from(Context context) {
+        return create(context);
+    }
+
+    @NonNull
+    public TaskStackBuilder addNextIntent(@NonNull Intent intent) {
+        this.mIntents.add(intent);
+        return this;
+    }
+
+    @NonNull
+    public TaskStackBuilder addNextIntentWithParentStack(@NonNull Intent intent) {
+        ComponentName component = intent.getComponent();
+        if (component == null) {
+            component = intent.resolveActivity(this.mSourceContext.getPackageManager());
+        }
+        if (component != null) {
+            addParentStack(component);
+        }
+        addNextIntent(intent);
+        return this;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @NonNull
+    public TaskStackBuilder addParentStack(@NonNull Activity activity) {
+        Intent supportParentActivityIntent = activity instanceof SupportParentable ? ((SupportParentable) activity).getSupportParentActivityIntent() : null;
+        if (supportParentActivityIntent == null) {
+            supportParentActivityIntent = NavUtils.getParentActivityIntent(activity);
+        }
+        if (supportParentActivityIntent != null) {
+            ComponentName component = supportParentActivityIntent.getComponent();
+            if (component == null) {
+                component = supportParentActivityIntent.resolveActivity(this.mSourceContext.getPackageManager());
+            }
+            addParentStack(component);
+            addNextIntent(supportParentActivityIntent);
+        }
+        return this;
+    }
+
+    @NonNull
+    public TaskStackBuilder addParentStack(@NonNull Class<?> cls) {
+        return addParentStack(new ComponentName(this.mSourceContext, cls));
+    }
+
+    @NonNull
+    public TaskStackBuilder addParentStack(@NonNull ComponentName componentName) {
+        int size = this.mIntents.size();
+        try {
+            Intent parentActivityIntent = NavUtils.getParentActivityIntent(this.mSourceContext, componentName);
+            while (parentActivityIntent != null) {
+                this.mIntents.add(size, parentActivityIntent);
+                parentActivityIntent = NavUtils.getParentActivityIntent(this.mSourceContext, parentActivityIntent.getComponent());
+            }
+            return this;
+        } catch (PackageManager.NameNotFoundException e) {
+            Log.e(TAG, "Bad ComponentName while traversing activity parent metadata");
+            throw new IllegalArgumentException(e);
+        }
+    }
+
+    public int getIntentCount() {
+        return this.mIntents.size();
+    }
+
+    @Deprecated
+    public Intent getIntent(int i) {
+        return editIntentAt(i);
+    }
+
+    @Nullable
+    public Intent editIntentAt(int i) {
+        return this.mIntents.get(i);
+    }
+
+    @Override // java.lang.Iterable
+    @NonNull
+    @Deprecated
+    public Iterator<Intent> iterator() {
+        return this.mIntents.iterator();
+    }
+
+    public void startActivities() {
+        startActivities(null);
+    }
+
+    public void startActivities(@Nullable Bundle bundle) {
+        if (this.mIntents.isEmpty()) {
+            throw new IllegalStateException("No intents added to TaskStackBuilder; cannot startActivities");
+        }
+        Intent[] intentArr = (Intent[]) this.mIntents.toArray(new Intent[0]);
+        intentArr[0] = new Intent(intentArr[0]).addFlags(268484608);
+        if (ContextCompat.startActivities(this.mSourceContext, intentArr, bundle)) {
+            return;
+        }
+        Intent intent = new Intent(intentArr[intentArr.length - 1]);
+        intent.addFlags(DriveFile.MODE_READ_ONLY);
+        this.mSourceContext.startActivity(intent);
+    }
+
+    @Nullable
+    public PendingIntent getPendingIntent(int i, int i2) {
+        return getPendingIntent(i, i2, null);
+    }
+
+    @Nullable
+    public PendingIntent getPendingIntent(int i, int i2, @Nullable Bundle bundle) {
+        if (this.mIntents.isEmpty()) {
+            throw new IllegalStateException("No intents added to TaskStackBuilder; cannot getPendingIntent");
+        }
+        Intent[] intentArr = (Intent[]) this.mIntents.toArray(new Intent[0]);
+        intentArr[0] = new Intent(intentArr[0]).addFlags(268484608);
+        return PendingIntent.getActivities(this.mSourceContext, i, intentArr, i2, bundle);
+    }
+
+    @NonNull
+    public Intent[] getIntents() {
+        int size = this.mIntents.size();
+        Intent[] intentArr = new Intent[size];
+        if (size == 0) {
+            return intentArr;
+        }
+        intentArr[0] = new Intent(this.mIntents.get(0)).addFlags(268484608);
+        for (int i = 1; i < size; i++) {
+            intentArr[i] = new Intent(this.mIntents.get(i));
+        }
+        return intentArr;
+    }
+}

decompiled/sources/androidx/core/app/unusedapprestrictions/IUnusedAppRestrictionsBackportCallback.java

@@ -0,0 +1,98 @@
+package androidx.core.app.unusedapprestrictions;
+
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Parcel;
+import android.os.RemoteException;
+import androidx.annotation.RestrictTo;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public interface IUnusedAppRestrictionsBackportCallback extends IInterface {
+    public static final String DESCRIPTOR = "androidx$core$app$unusedapprestrictions$IUnusedAppRestrictionsBackportCallback".replace('$', '.');
+
+    public static class Default implements IUnusedAppRestrictionsBackportCallback {
+        @Override // android.os.IInterface
+        public IBinder asBinder() {
+            return null;
+        }
+
+        @Override // androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportCallback
+        public void onIsPermissionRevocationEnabledForAppResult(boolean z, boolean z2) throws RemoteException {
+        }
+    }
+
+    void onIsPermissionRevocationEnabledForAppResult(boolean z, boolean z2) throws RemoteException;
+
+    public static abstract class Stub extends Binder implements IUnusedAppRestrictionsBackportCallback {
+        static final int TRANSACTION_onIsPermissionRevocationEnabledForAppResult = 1;
+
+        @Override // android.os.IInterface
+        public IBinder asBinder() {
+            return this;
+        }
+
+        public Stub() {
+            attachInterface(this, IUnusedAppRestrictionsBackportCallback.DESCRIPTOR);
+        }
+
+        public static IUnusedAppRestrictionsBackportCallback asInterface(IBinder iBinder) {
+            if (iBinder == null) {
+                return null;
+            }
+            IInterface queryLocalInterface = iBinder.queryLocalInterface(IUnusedAppRestrictionsBackportCallback.DESCRIPTOR);
+            if (queryLocalInterface != null && (queryLocalInterface instanceof IUnusedAppRestrictionsBackportCallback)) {
+                return (IUnusedAppRestrictionsBackportCallback) queryLocalInterface;
+            }
+            return new Proxy(iBinder);
+        }
+
+        @Override // android.os.Binder
+        public boolean onTransact(int i, Parcel parcel, Parcel parcel2, int i2) throws RemoteException {
+            String str = IUnusedAppRestrictionsBackportCallback.DESCRIPTOR;
+            if (i >= 1 && i <= 16777215) {
+                parcel.enforceInterface(str);
+            }
+            if (i == 1598968902) {
+                parcel2.writeString(str);
+                return true;
+            }
+            if (i == 1) {
+                onIsPermissionRevocationEnabledForAppResult(parcel.readInt() != 0, parcel.readInt() != 0);
+                return true;
+            }
+            return super.onTransact(i, parcel, parcel2, i2);
+        }
+
+        public static class Proxy implements IUnusedAppRestrictionsBackportCallback {
+            private IBinder mRemote;
+
+            @Override // android.os.IInterface
+            public IBinder asBinder() {
+                return this.mRemote;
+            }
+
+            public String getInterfaceDescriptor() {
+                return IUnusedAppRestrictionsBackportCallback.DESCRIPTOR;
+            }
+
+            public Proxy(IBinder iBinder) {
+                this.mRemote = iBinder;
+            }
+
+            @Override // androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportCallback
+            public void onIsPermissionRevocationEnabledForAppResult(boolean z, boolean z2) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IUnusedAppRestrictionsBackportCallback.DESCRIPTOR);
+                    obtain.writeInt(z ? 1 : 0);
+                    obtain.writeInt(z2 ? 1 : 0);
+                    this.mRemote.transact(1, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+        }
+    }
+}

decompiled/sources/androidx/core/app/unusedapprestrictions/IUnusedAppRestrictionsBackportService.java

@@ -0,0 +1,98 @@
+package androidx.core.app.unusedapprestrictions;
+
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Parcel;
+import android.os.RemoteException;
+import androidx.annotation.RestrictTo;
+import androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportCallback;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes.dex */
+public interface IUnusedAppRestrictionsBackportService extends IInterface {
+    public static final String DESCRIPTOR = "androidx$core$app$unusedapprestrictions$IUnusedAppRestrictionsBackportService".replace('$', '.');
+
+    public static class Default implements IUnusedAppRestrictionsBackportService {
+        @Override // android.os.IInterface
+        public IBinder asBinder() {
+            return null;
+        }
+
+        @Override // androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportService
+        public void isPermissionRevocationEnabledForApp(IUnusedAppRestrictionsBackportCallback iUnusedAppRestrictionsBackportCallback) throws RemoteException {
+        }
+    }
+
+    void isPermissionRevocationEnabledForApp(IUnusedAppRestrictionsBackportCallback iUnusedAppRestrictionsBackportCallback) throws RemoteException;
+
+    public static abstract class Stub extends Binder implements IUnusedAppRestrictionsBackportService {
+        static final int TRANSACTION_isPermissionRevocationEnabledForApp = 1;
+
+        @Override // android.os.IInterface
+        public IBinder asBinder() {
+            return this;
+        }
+
+        public Stub() {
+            attachInterface(this, IUnusedAppRestrictionsBackportService.DESCRIPTOR);
+        }
+
+        public static IUnusedAppRestrictionsBackportService asInterface(IBinder iBinder) {
+            if (iBinder == null) {
+                return null;
+            }
+            IInterface queryLocalInterface = iBinder.queryLocalInterface(IUnusedAppRestrictionsBackportService.DESCRIPTOR);
+            if (queryLocalInterface != null && (queryLocalInterface instanceof IUnusedAppRestrictionsBackportService)) {
+                return (IUnusedAppRestrictionsBackportService) queryLocalInterface;
+            }
+            return new Proxy(iBinder);
+        }
+
+        @Override // android.os.Binder
+        public boolean onTransact(int i, Parcel parcel, Parcel parcel2, int i2) throws RemoteException {
+            String str = IUnusedAppRestrictionsBackportService.DESCRIPTOR;
+            if (i >= 1 && i <= 16777215) {
+                parcel.enforceInterface(str);
+            }
+            if (i == 1598968902) {
+                parcel2.writeString(str);
+                return true;
+            }
+            if (i == 1) {
+                isPermissionRevocationEnabledForApp(IUnusedAppRestrictionsBackportCallback.Stub.asInterface(parcel.readStrongBinder()));
+                return true;
+            }
+            return super.onTransact(i, parcel, parcel2, i2);
+        }
+
+        public static class Proxy implements IUnusedAppRestrictionsBackportService {
+            private IBinder mRemote;
+
+            @Override // android.os.IInterface
+            public IBinder asBinder() {
+                return this.mRemote;
+            }
+
+            public String getInterfaceDescriptor() {
+                return IUnusedAppRestrictionsBackportService.DESCRIPTOR;
+            }
+
+            public Proxy(IBinder iBinder) {
+                this.mRemote = iBinder;
+            }
+
+            @Override // androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportService
+            public void isPermissionRevocationEnabledForApp(IUnusedAppRestrictionsBackportCallback iUnusedAppRestrictionsBackportCallback) throws RemoteException {
+                Parcel obtain = Parcel.obtain();
+                try {
+                    obtain.writeInterfaceToken(IUnusedAppRestrictionsBackportService.DESCRIPTOR);
+                    obtain.writeStrongInterface(iUnusedAppRestrictionsBackportCallback);
+                    this.mRemote.transact(1, obtain, null, 1);
+                } finally {
+                    obtain.recycle();
+                }
+            }
+        }
+    }
+}

decompiled/sources/androidx/core/content/ContentProviderCompat.java

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

decompiled/sources/androidx/core/content/ContentResolverCompat.java

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

decompiled/sources/androidx/core/content/ContentValuesKt.java

@@ -0,0 +1,40 @@
+package androidx.core.content;
+
+import android.content.ContentValues;
+import kotlin.Pair;
+
+/* loaded from: classes.dex */
+public final class ContentValuesKt {
+    public static final ContentValues contentValuesOf(Pair... pairArr) {
+        ContentValues contentValues = new ContentValues(pairArr.length);
+        for (Pair pair : pairArr) {
+            String str = (String) pair.component1();
+            Object component2 = pair.component2();
+            if (component2 == null) {
+                contentValues.putNull(str);
+            } else if (component2 instanceof String) {
+                contentValues.put(str, (String) component2);
+            } else if (component2 instanceof Integer) {
+                contentValues.put(str, (Integer) component2);
+            } else if (component2 instanceof Long) {
+                contentValues.put(str, (Long) component2);
+            } else if (component2 instanceof Boolean) {
+                contentValues.put(str, (Boolean) component2);
+            } else if (component2 instanceof Float) {
+                contentValues.put(str, (Float) component2);
+            } else if (component2 instanceof Double) {
+                contentValues.put(str, (Double) component2);
+            } else if (component2 instanceof byte[]) {
+                contentValues.put(str, (byte[]) component2);
+            } else if (component2 instanceof Byte) {
+                contentValues.put(str, (Byte) component2);
+            } else {
+                if (!(component2 instanceof Short)) {
+                    throw new IllegalArgumentException("Illegal value type " + component2.getClass().getCanonicalName() + " for key \"" + str + '\"');
+                }
+                contentValues.put(str, (Short) component2);
+            }
+        }
+        return contentValues;
+    }
+}

decompiled/sources/androidx/core/content/ContextCompat.java

@@ -0,0 +1,482 @@
+package androidx.core.content;
+
+import android.accounts.AccountManager;
+import android.annotation.SuppressLint;
+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.content.res.Configuration;
+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.SubscriptionManager;
+import android.telephony.TelephonyManager;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.Display;
+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.annotation.ColorInt;
+import androidx.annotation.ColorRes;
+import androidx.annotation.DrawableRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.ReplaceWith;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.core.app.LocaleManagerCompat;
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.NotificationManagerCompat;
+import androidx.core.content.res.ResourcesCompat;
+import androidx.core.os.ConfigurationCompat;
+import androidx.core.os.ExecutorCompat;
+import androidx.core.os.LocaleListCompat;
+import androidx.core.util.ObjectsCompat;
+import com.applovin.sdk.AppLovinEventTypes;
+import com.ironsource.r8;
+import com.ironsource.v8;
+import com.vungle.ads.internal.presenter.NativeAdPresenter;
+import java.io.File;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.HashMap;
+import java.util.concurrent.Executor;
+
+@SuppressLint({"PrivateConstructorForUtilityClass"})
+/* 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 sSync = new Object();
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public @interface RegisterReceiverFlags {
+    }
+
+    public static boolean startActivities(@NonNull Context context, @NonNull Intent[] intentArr) {
+        return startActivities(context, intentArr, null);
+    }
+
+    public static boolean startActivities(@NonNull Context context, @NonNull Intent[] intentArr, @Nullable Bundle bundle) {
+        context.startActivities(intentArr, bundle);
+        return true;
+    }
+
+    @ReplaceWith(expression = "context.startActivity(intent, options)")
+    @Deprecated
+    public static void startActivity(@NonNull Context context, @NonNull Intent intent, @Nullable Bundle bundle) {
+        context.startActivity(intent, bundle);
+    }
+
+    @Nullable
+    public static File getDataDir(@NonNull Context context) {
+        return Api24Impl.getDataDir(context);
+    }
+
+    @NonNull
+    @ReplaceWith(expression = "context.getObbDirs()")
+    @Deprecated
+    public static File[] getObbDirs(@NonNull Context context) {
+        return context.getObbDirs();
+    }
+
+    @NonNull
+    @ReplaceWith(expression = "context.getExternalFilesDirs(type)")
+    @Deprecated
+    public static File[] getExternalFilesDirs(@NonNull Context context, @Nullable String str) {
+        return context.getExternalFilesDirs(str);
+    }
+
+    @NonNull
+    @ReplaceWith(expression = "context.getExternalCacheDirs()")
+    @Deprecated
+    public static File[] getExternalCacheDirs(@NonNull Context context) {
+        return context.getExternalCacheDirs();
+    }
+
+    @Nullable
+    public static Drawable getDrawable(@NonNull Context context, @DrawableRes int i) {
+        return Api21Impl.getDrawable(context, i);
+    }
+
+    @Nullable
+    public static ColorStateList getColorStateList(@NonNull Context context, @ColorRes int i) {
+        return ResourcesCompat.getColorStateList(context.getResources(), i, context.getTheme());
+    }
+
+    @ColorInt
+    public static int getColor(@NonNull Context context, @ColorRes int i) {
+        return Api23Impl.getColor(context, i);
+    }
+
+    public static int checkSelfPermission(@NonNull Context context, @NonNull String str) {
+        ObjectsCompat.requireNonNull(str, "permission must be non-null");
+        if (Build.VERSION.SDK_INT >= 33 || !TextUtils.equals("android.permission.POST_NOTIFICATIONS", str)) {
+            return context.checkPermission(str, Process.myPid(), Process.myUid());
+        }
+        return NotificationManagerCompat.from(context).areNotificationsEnabled() ? 0 : -1;
+    }
+
+    @Nullable
+    public static File getNoBackupFilesDir(@NonNull Context context) {
+        return Api21Impl.getNoBackupFilesDir(context);
+    }
+
+    @NonNull
+    public static File getCodeCacheDir(@NonNull Context context) {
+        return Api21Impl.getCodeCacheDir(context);
+    }
+
+    private static File createFilesDir(File file) {
+        synchronized (sSync) {
+            try {
+                if (!file.exists()) {
+                    if (file.mkdirs()) {
+                        return file;
+                    }
+                    Log.w(TAG, "Unable to create files subdir " + file.getPath());
+                }
+                return file;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Nullable
+    public static Context createDeviceProtectedStorageContext(@NonNull Context context) {
+        return Api24Impl.createDeviceProtectedStorageContext(context);
+    }
+
+    public static boolean isDeviceProtectedStorage(@NonNull Context context) {
+        return Api24Impl.isDeviceProtectedStorage(context);
+    }
+
+    @NonNull
+    public static Executor getMainExecutor(@NonNull Context context) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.getMainExecutor(context);
+        }
+        return ExecutorCompat.create(new Handler(context.getMainLooper()));
+    }
+
+    public static void startForegroundService(@NonNull Context context, @NonNull Intent intent) {
+        Api26Impl.startForegroundService(context, intent);
+    }
+
+    @NonNull
+    public static Display getDisplayOrDefault(@NonNull Context context) {
+        if (Build.VERSION.SDK_INT >= 30) {
+            return Api30Impl.getDisplayOrDefault(context);
+        }
+        return ((WindowManager) context.getSystemService("window")).getDefaultDisplay();
+    }
+
+    @Nullable
+    public static <T> T getSystemService(@NonNull Context context, @NonNull Class<T> cls) {
+        return (T) Api23Impl.getSystemService(context, cls);
+    }
+
+    @Nullable
+    public static Intent registerReceiver(@NonNull Context context, @Nullable BroadcastReceiver broadcastReceiver, @NonNull IntentFilter intentFilter, int i) {
+        return registerReceiver(context, broadcastReceiver, intentFilter, null, null, i);
+    }
+
+    @Nullable
+    public static Intent registerReceiver(@NonNull Context context, @Nullable BroadcastReceiver broadcastReceiver, @NonNull IntentFilter intentFilter, @Nullable String str, @Nullable 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 (Build.VERSION.SDK_INT >= 33) {
+            return Api33Impl.registerReceiver(context, broadcastReceiver, intentFilter, str, handler, i3);
+        }
+        return Api26Impl.registerReceiver(context, broadcastReceiver, intentFilter, str, handler, i3);
+    }
+
+    @Nullable
+    public static String getSystemServiceName(@NonNull Context context, @NonNull Class<?> cls) {
+        return Api23Impl.getSystemServiceName(context, cls);
+    }
+
+    @NonNull
+    public static String getString(@NonNull Context context, int i) {
+        return getContextForLanguage(context).getString(i);
+    }
+
+    @NonNull
+    public static Context getContextForLanguage(@NonNull Context context) {
+        LocaleListCompat applicationLocales = LocaleManagerCompat.getApplicationLocales(context);
+        if (Build.VERSION.SDK_INT > 32 || applicationLocales.isEmpty()) {
+            return context;
+        }
+        Configuration configuration = new Configuration(context.getResources().getConfiguration());
+        ConfigurationCompat.setLocales(configuration, applicationLocales);
+        return context.createConfigurationContext(configuration);
+    }
+
+    @Nullable
+    public static String getAttributionTag(@NonNull Context context) {
+        if (Build.VERSION.SDK_INT >= 30) {
+            return Api30Impl.getAttributionTag(context);
+        }
+        return null;
+    }
+
+    @NonNull
+    public static Context createAttributionContext(@NonNull Context context, @Nullable String str) {
+        return Build.VERSION.SDK_INT >= 30 ? Api30Impl.createAttributionContext(context, str) : context;
+    }
+
+    public 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");
+    }
+
+    public static final class LegacyServiceMapHolder {
+        static final HashMap<Class<?>, String> SERVICES;
+
+        private LegacyServiceMapHolder() {
+        }
+
+        static {
+            HashMap<Class<?>, String> hashMap = new HashMap<>();
+            SERVICES = hashMap;
+            hashMap.put(SubscriptionManager.class, "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, r8.d);
+            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, NativeAdPresenter.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, AppLovinEventTypes.USER_EXECUTED_SEARCH);
+            hashMap.put(SensorManager.class, "sensor");
+            hashMap.put(StorageManager.class, v8.a.j);
+            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");
+        }
+    }
+
+    @RequiresApi(21)
+    public static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        public static Drawable getDrawable(Context context, int i) {
+            return context.getDrawable(i);
+        }
+
+        public static File getNoBackupFilesDir(Context context) {
+            return context.getNoBackupFilesDir();
+        }
+
+        public static File getCodeCacheDir(Context context) {
+            return context.getCodeCacheDir();
+        }
+    }
+
+    @RequiresApi(23)
+    public static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        public static int getColor(Context context, int i) {
+            return context.getColor(i);
+        }
+
+        public static <T> T getSystemService(Context context, Class<T> cls) {
+            return (T) context.getSystemService(cls);
+        }
+
+        public static String getSystemServiceName(Context context, Class<?> cls) {
+            return context.getSystemServiceName(cls);
+        }
+    }
+
+    @RequiresApi(24)
+    public static class Api24Impl {
+        private Api24Impl() {
+        }
+
+        public static File getDataDir(Context context) {
+            return context.getDataDir();
+        }
+
+        public static Context createDeviceProtectedStorageContext(Context context) {
+            return context.createDeviceProtectedStorageContext();
+        }
+
+        public static boolean isDeviceProtectedStorage(Context context) {
+            return context.isDeviceProtectedStorage();
+        }
+    }
+
+    @RequiresApi(26)
+    public static class Api26Impl {
+        private Api26Impl() {
+        }
+
+        public static Intent registerReceiver(Context context, @Nullable 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);
+        }
+
+        public static ComponentName startForegroundService(Context context, Intent intent) {
+            return context.startForegroundService(intent);
+        }
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static Executor getMainExecutor(Context context) {
+            return context.getMainExecutor();
+        }
+    }
+
+    @RequiresApi(30)
+    public static class Api30Impl {
+        private Api30Impl() {
+        }
+
+        public static String getAttributionTag(Context context) {
+            return context.getAttributionTag();
+        }
+
+        public static Display getDisplayOrDefault(Context context) {
+            try {
+                return context.getDisplay();
+            } catch (UnsupportedOperationException unused) {
+                Log.w(ContextCompat.TAG, "The context:" + context + " is not associated with any display. Return a fallback display instead.");
+                return ((DisplayManager) context.getSystemService(DisplayManager.class)).getDisplay(0);
+            }
+        }
+
+        @NonNull
+        public static Context createAttributionContext(@NonNull Context context, @Nullable String str) {
+            return context.createAttributionContext(str);
+        }
+    }
+
+    @RequiresApi(33)
+    public static class Api33Impl {
+        private Api33Impl() {
+        }
+
+        public static Intent registerReceiver(Context context, @Nullable BroadcastReceiver broadcastReceiver, IntentFilter intentFilter, String str, Handler handler, int i) {
+            return context.registerReceiver(broadcastReceiver, intentFilter, str, handler, i);
+        }
+    }
+}

decompiled/sources/androidx/core/content/ContextKt.java

@@ -0,0 +1,45 @@
+package androidx.core.content;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.util.AttributeSet;
+import androidx.annotation.AttrRes;
+import androidx.annotation.StyleRes;
+import com.google.android.gms.ads.RequestConfiguration;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class ContextKt {
+    public static final /* synthetic */ <T> T getSystemService(Context context) {
+        Intrinsics.reifiedOperationMarker(4, RequestConfiguration.MAX_AD_CONTENT_RATING_T);
+        return (T) ContextCompat.getSystemService(context, Object.class);
+    }
+
+    public static final void withStyledAttributes(Context context, AttributeSet attributeSet, int[] iArr, @AttrRes int i, @StyleRes int i2, Function1 function1) {
+        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, iArr, i, i2);
+        function1.invoke(obtainStyledAttributes);
+        obtainStyledAttributes.recycle();
+    }
+
+    public static /* synthetic */ void withStyledAttributes$default(Context context, AttributeSet attributeSet, int[] iArr, int i, int i2, Function1 function1, int i3, Object obj) {
+        if ((i3 & 1) != 0) {
+            attributeSet = null;
+        }
+        if ((i3 & 4) != 0) {
+            i = 0;
+        }
+        if ((i3 & 8) != 0) {
+            i2 = 0;
+        }
+        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, iArr, i, i2);
+        function1.invoke(obtainStyledAttributes);
+        obtainStyledAttributes.recycle();
+    }
+
+    public static final void withStyledAttributes(Context context, @StyleRes int i, int[] iArr, Function1 function1) {
+        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(i, iArr);
+        function1.invoke(obtainStyledAttributes);
+        obtainStyledAttributes.recycle();
+    }
+}

decompiled/sources/androidx/core/content/FileProvider.java

@@ -0,0 +1,421 @@
+package androidx.core.content;
+
+import android.annotation.SuppressLint;
+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 androidx.annotation.CallSuper;
+import androidx.annotation.GuardedBy;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.VisibleForTesting;
+import androidx.annotation.XmlRes;
+import androidx.core.util.ObjectsCompat;
+import com.google.android.gms.drive.DriveFile;
+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";
+
+    @GuardedBy("mLock")
+    private String mAuthority;
+
+    @Nullable
+    @GuardedBy("mLock")
+    private PathStrategy mLocalPathStrategy;
+
+    @NonNull
+    private final Object mLock;
+    private final int mResourceId;
+    private static final String[] COLUMNS = {"_display_name", "_size"};
+    private static final File DEVICE_ROOT = new File("/");
+
+    @GuardedBy("sCache")
+    private static final HashMap<String, PathStrategy> sCache = new HashMap<>();
+
+    public interface PathStrategy {
+        File getFileForUri(Uri uri);
+
+        Uri getUriForFile(File file);
+    }
+
+    @Override // android.content.ContentProvider
+    @Nullable
+    public String getTypeAnonymous(@NonNull Uri uri) {
+        return "application/octet-stream";
+    }
+
+    @Override // android.content.ContentProvider
+    public boolean onCreate() {
+        return true;
+    }
+
+    public FileProvider() {
+        this(0);
+    }
+
+    public FileProvider(@XmlRes int i) {
+        this.mLock = new Object();
+        this.mResourceId = i;
+    }
+
+    @Override // android.content.ContentProvider
+    @CallSuper
+    public void attachInfo(@NonNull Context context, @NonNull 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];
+        synchronized (this.mLock) {
+            this.mAuthority = str;
+        }
+        HashMap<String, PathStrategy> hashMap = sCache;
+        synchronized (hashMap) {
+            hashMap.remove(str);
+        }
+    }
+
+    public static Uri getUriForFile(@NonNull Context context, @NonNull String str, @NonNull File file) {
+        return getPathStrategy(context, str, 0).getUriForFile(file);
+    }
+
+    @NonNull
+    @SuppressLint({"StreamFiles"})
+    public static Uri getUriForFile(@NonNull Context context, @NonNull String str, @NonNull File file, @NonNull String str2) {
+        return getUriForFile(context, str, file).buildUpon().appendQueryParameter(DISPLAYNAME_FIELD, str2).build();
+    }
+
+    @Override // android.content.ContentProvider
+    @NonNull
+    public Cursor query(@NonNull Uri uri, @Nullable String[] strArr, @Nullable String str, @Nullable String[] strArr2, @Nullable String str2) {
+        int i;
+        File fileForUri = getLocalPathStrategy().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
+    @Nullable
+    public String getType(@NonNull Uri uri) {
+        File fileForUri = getLocalPathStrategy().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(@NonNull Uri uri, @NonNull ContentValues contentValues) {
+        throw new UnsupportedOperationException("No external inserts");
+    }
+
+    @Override // android.content.ContentProvider
+    public int update(@NonNull Uri uri, @NonNull ContentValues contentValues, @Nullable String str, @Nullable String[] strArr) {
+        throw new UnsupportedOperationException("No external updates");
+    }
+
+    @Override // android.content.ContentProvider
+    public int delete(@NonNull Uri uri, @Nullable String str, @Nullable String[] strArr) {
+        return getLocalPathStrategy().getFileForUri(uri).delete() ? 1 : 0;
+    }
+
+    @Override // android.content.ContentProvider
+    @SuppressLint({"UnknownNullness"})
+    public ParcelFileDescriptor openFile(@NonNull Uri uri, @NonNull String str) throws FileNotFoundException {
+        return ParcelFileDescriptor.open(getLocalPathStrategy().getFileForUri(uri), modeToMode(str));
+    }
+
+    @NonNull
+    private PathStrategy getLocalPathStrategy() {
+        PathStrategy pathStrategy;
+        synchronized (this.mLock) {
+            try {
+                ObjectsCompat.requireNonNull(this.mAuthority, "mAuthority is null. Did you override attachInfo and did not call super.attachInfo()?");
+                if (this.mLocalPathStrategy == null) {
+                    this.mLocalPathStrategy = getPathStrategy(getContext(), this.mAuthority, this.mResourceId);
+                }
+                pathStrategy = this.mLocalPathStrategy;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return pathStrategy;
+    }
+
+    private static PathStrategy getPathStrategy(Context context, String str, int i) {
+        PathStrategy pathStrategy;
+        HashMap<String, PathStrategy> hashMap = sCache;
+        synchronized (hashMap) {
+            try {
+                pathStrategy = hashMap.get(str);
+                if (pathStrategy == null) {
+                    try {
+                        try {
+                            pathStrategy = parsePathStrategy(context, str, i);
+                            hashMap.put(str, pathStrategy);
+                        } catch (IOException e) {
+                            throw new IllegalArgumentException("Failed to parse android.support.FILE_PROVIDER_PATHS meta-data", e);
+                        }
+                    } catch (XmlPullParserException e2) {
+                        throw new IllegalArgumentException("Failed to parse android.support.FILE_PROVIDER_PATHS meta-data", e2);
+                    }
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return pathStrategy;
+    }
+
+    @VisibleForTesting
+    public static XmlResourceParser getFileProviderPathsMetaData(Context context, String str, @Nullable 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) {
+            Bundle bundle = new Bundle(1);
+            providerInfo.metaData = bundle;
+            bundle.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, "name");
+                String attributeValue2 = fileProviderPathsMetaData.getAttributeValue(null, "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));
+                }
+            }
+        }
+    }
+
+    public static class SimplePathStrategy implements PathStrategy {
+        private final String mAuthority;
+        private final HashMap<String, File> mRoots = new HashMap<>();
+
+        public SimplePathStrategy(String str) {
+            this.mAuthority = str;
+        }
+
+        public 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 (belongsToRoot(canonicalPath, 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 (belongsToRoot(canonicalFile.getPath(), 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 boolean belongsToRoot(@NonNull String str, @NonNull String str2) {
+            String removeTrailingSlash = FileProvider.removeTrailingSlash(str);
+            String removeTrailingSlash2 = FileProvider.removeTrailingSlash(str2);
+            if (!removeTrailingSlash.equals(removeTrailingSlash2)) {
+                if (!removeTrailingSlash.startsWith(removeTrailingSlash2 + '/')) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    private static int modeToMode(String str) {
+        if ("r".equals(str)) {
+            return DriveFile.MODE_READ_ONLY;
+        }
+        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;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    @NonNull
+    public static String removeTrailingSlash(@NonNull String str) {
+        return (str.length() <= 0 || str.charAt(str.length() + (-1)) != '/') ? str : str.substring(0, str.length() - 1);
+    }
+
+    @RequiresApi(21)
+    public static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        public static File[] getExternalMediaDirs(Context context) {
+            return context.getExternalMediaDirs();
+        }
+    }
+}

decompiled/sources/androidx/core/content/IntentCompat.java

@@ -0,0 +1,112 @@
+package androidx.core.content;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.util.Preconditions;
+import java.io.Serializable;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+public final class IntentCompat {
+
+    @SuppressLint({"ActionValue"})
+    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";
+
+    @SuppressLint({"ActionValue"})
+    public static final String EXTRA_TIME = "android.intent.extra.TIME";
+
+    private IntentCompat() {
+    }
+
+    @NonNull
+    public static Intent makeMainSelectorActivity(@NonNull String str, @NonNull String str2) {
+        return Intent.makeMainSelectorActivity(str, str2);
+    }
+
+    @NonNull
+    public static Intent createManageUnusedAppRestrictionsIntent(@NonNull Context context, @NonNull String str) {
+        if (!PackageManagerCompat.areUnusedAppRestrictionsAvailable(context.getPackageManager())) {
+            throw new UnsupportedOperationException("Unused App Restriction features are not available on this device");
+        }
+        int i = Build.VERSION.SDK_INT;
+        if (i >= 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 i >= 30 ? data : data.setPackage((String) Preconditions.checkNotNull(PackageManagerCompat.getPermissionRevocationVerifierApp(context.getPackageManager())));
+    }
+
+    @Nullable
+    public static <T> T getParcelableExtra(@NonNull Intent intent, @Nullable String str, @NonNull Class<T> cls) {
+        if (Build.VERSION.SDK_INT >= 34) {
+            return (T) Api33Impl.getParcelableExtra(intent, str, cls);
+        }
+        T t = (T) intent.getParcelableExtra(str);
+        if (cls.isInstance(t)) {
+            return t;
+        }
+        return null;
+    }
+
+    @Nullable
+    @SuppressLint({"ArrayReturn", "NullableCollection"})
+    public static Parcelable[] getParcelableArrayExtra(@NonNull Intent intent, @Nullable String str, @NonNull Class<? extends Parcelable> cls) {
+        if (Build.VERSION.SDK_INT >= 34) {
+            return (Parcelable[]) Api33Impl.getParcelableArrayExtra(intent, str, cls);
+        }
+        return intent.getParcelableArrayExtra(str);
+    }
+
+    @Nullable
+    @SuppressLint({"ConcreteCollection", "NullableCollection"})
+    public static <T> ArrayList<T> getParcelableArrayListExtra(@NonNull Intent intent, @Nullable String str, @NonNull Class<? extends T> cls) {
+        if (Build.VERSION.SDK_INT >= 34) {
+            return Api33Impl.getParcelableArrayListExtra(intent, str, cls);
+        }
+        return intent.getParcelableArrayListExtra(str);
+    }
+
+    @Nullable
+    public static <T extends Serializable> T getSerializableExtra(@NonNull Intent intent, @Nullable String str, @NonNull Class<T> cls) {
+        if (Build.VERSION.SDK_INT >= 34) {
+            return (T) Api33Impl.getSerializableExtra(intent, str, cls);
+        }
+        T t = (T) intent.getSerializableExtra(str);
+        if (cls.isInstance(t)) {
+            return t;
+        }
+        return null;
+    }
+
+    @RequiresApi(33)
+    public static class Api33Impl {
+        private Api33Impl() {
+        }
+
+        public static <T> T getParcelableExtra(@NonNull Intent intent, @Nullable String str, @NonNull Class<T> cls) {
+            return (T) intent.getParcelableExtra(str, cls);
+        }
+
+        public static <T> T[] getParcelableArrayExtra(@NonNull Intent intent, @Nullable String str, @NonNull Class<T> cls) {
+            return (T[]) intent.getParcelableArrayExtra(str, cls);
+        }
+
+        public static <T> ArrayList<T> getParcelableArrayListExtra(@NonNull Intent intent, @Nullable String str, @NonNull Class<? extends T> cls) {
+            return intent.getParcelableArrayListExtra(str, cls);
+        }
+
+        public static <T extends Serializable> T getSerializableExtra(@NonNull Intent intent, @Nullable String str, @NonNull Class<T> cls) {
+            return (T) intent.getSerializableExtra(str, cls);
+        }
+    }
+}

decompiled/sources/androidx/core/content/IntentSanitizer$Builder$$ExternalSyntheticLambda11.java

@@ -0,0 +1,13 @@
+package androidx.core.content;
+
+import androidx.core.util.Predicate;
+
+/* loaded from: classes.dex */
+public final /* synthetic */ class IntentSanitizer$Builder$$ExternalSyntheticLambda11 implements Predicate {
+    public final /* synthetic */ String f$0;
+
+    @Override // androidx.core.util.Predicate
+    public final boolean test(Object obj) {
+        return this.f$0.equals((String) obj);
+    }
+}

decompiled/sources/androidx/core/content/IntentSanitizer.java

@@ -0,0 +1,832 @@
+package androidx.core.content;
+
+import android.annotation.SuppressLint;
+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 androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+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;
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static /* synthetic */ void lambda$sanitizeByFiltering$0(String str) {
+    }
+
+    private IntentSanitizer() {
+    }
+
+    @NonNull
+    public Intent sanitizeByFiltering(@NonNull 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);
+            }
+        });
+    }
+
+    @NonNull
+    public Intent sanitizeByThrowing(@NonNull 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);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static /* synthetic */ void lambda$sanitizeByThrowing$1(String str) {
+        throw new SecurityException(str);
+    }
+
+    @NonNull
+    public Intent sanitize(@NonNull Intent intent, @NonNull 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);
+                    }
+                }
+            }
+        }
+        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) {
+            intent2.setSelector(intent.getSelector());
+        } else if (intent.getSelector() != null) {
+            consumer.accept("Selector is not allowed: " + intent.getSelector());
+        }
+        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);
+                return;
+            }
+            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$$ExternalSyntheticLambda2
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                boolean lambda$new$0;
+                lambda$new$0 = IntentSanitizer.Builder.lambda$new$0((String) obj);
+                return lambda$new$0;
+            }
+        };
+        private Predicate<Uri> mAllowedData = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda3
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                boolean lambda$new$1;
+                lambda$new$1 = IntentSanitizer.Builder.lambda$new$1((Uri) obj);
+                return lambda$new$1;
+            }
+        };
+        private Predicate<String> mAllowedTypes = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda4
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                boolean lambda$new$2;
+                lambda$new$2 = IntentSanitizer.Builder.lambda$new$2((String) obj);
+                return lambda$new$2;
+            }
+        };
+        private Predicate<String> mAllowedCategories = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda5
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                boolean lambda$new$3;
+                lambda$new$3 = IntentSanitizer.Builder.lambda$new$3((String) obj);
+                return lambda$new$3;
+            }
+        };
+        private Predicate<String> mAllowedPackages = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda6
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                boolean lambda$new$4;
+                lambda$new$4 = IntentSanitizer.Builder.lambda$new$4((String) obj);
+                return lambda$new$4;
+            }
+        };
+        private Predicate<ComponentName> mAllowedComponents = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda7
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                boolean lambda$new$5;
+                lambda$new$5 = IntentSanitizer.Builder.lambda$new$5((ComponentName) obj);
+                return lambda$new$5;
+            }
+        };
+        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$$ExternalSyntheticLambda8
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                boolean lambda$new$6;
+                lambda$new$6 = IntentSanitizer.Builder.lambda$new$6((Uri) obj);
+                return lambda$new$6;
+            }
+        };
+        private Predicate<ClipData> mAllowedClipData = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda9
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                boolean lambda$new$7;
+                lambda$new$7 = IntentSanitizer.Builder.lambda$new$7((ClipData) obj);
+                return lambda$new$7;
+            }
+        };
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$allowAnyComponent$10(ComponentName componentName) {
+            return true;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$allowExtra$12(Object obj) {
+            return true;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$allowExtra$14(Object obj) {
+            return false;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$new$0(String str) {
+            return false;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$new$1(Uri uri) {
+            return false;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$new$2(String str) {
+            return false;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$new$3(String str) {
+            return false;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$new$4(String str) {
+            return false;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$new$5(ComponentName componentName) {
+            return false;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$new$6(Uri uri) {
+            return false;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$new$7(ClipData clipData) {
+            return false;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowClipDataText() {
+            this.mAllowClipDataText = true;
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowFlags(int i) {
+            this.mAllowedFlags = i | this.mAllowedFlags;
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowHistoryStackFlags() {
+            this.mAllowedFlags |= HISTORY_STACK_FLAGS;
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowIdentifier() {
+            this.mAllowIdentifier = true;
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowReceiverFlags() {
+            this.mAllowedFlags |= RECEIVER_FLAGS;
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowSelector() {
+            this.mAllowSelector = true;
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowSourceBounds() {
+            this.mAllowSourceBounds = true;
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowAction(@NonNull String str) {
+            Preconditions.checkNotNull(str);
+            Objects.requireNonNull(str);
+            allowAction(new IntentSanitizer$Builder$$ExternalSyntheticLambda11(str));
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowAction(@NonNull Predicate<String> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowedActions = this.mAllowedActions.or(predicate);
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowDataWithAuthority(@NonNull final String str) {
+            Preconditions.checkNotNull(str);
+            allowData(new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda16
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    boolean lambda$allowDataWithAuthority$8;
+                    lambda$allowDataWithAuthority$8 = IntentSanitizer.Builder.lambda$allowDataWithAuthority$8(str, (Uri) obj);
+                    return lambda$allowDataWithAuthority$8;
+                }
+            });
+            return this;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$allowDataWithAuthority$8(String str, Uri uri) {
+            return str.equals(uri.getAuthority());
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowData(@NonNull Predicate<Uri> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowedData = this.mAllowedData.or(predicate);
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowType(@NonNull String str) {
+            Preconditions.checkNotNull(str);
+            Objects.requireNonNull(str);
+            return allowType(new IntentSanitizer$Builder$$ExternalSyntheticLambda11(str));
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowType(@NonNull Predicate<String> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowedTypes = this.mAllowedTypes.or(predicate);
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowCategory(@NonNull String str) {
+            Preconditions.checkNotNull(str);
+            Objects.requireNonNull(str);
+            return allowCategory(new IntentSanitizer$Builder$$ExternalSyntheticLambda11(str));
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowCategory(@NonNull Predicate<String> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowedCategories = this.mAllowedCategories.or(predicate);
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowPackage(@NonNull String str) {
+            Preconditions.checkNotNull(str);
+            Objects.requireNonNull(str);
+            return allowPackage(new IntentSanitizer$Builder$$ExternalSyntheticLambda11(str));
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowPackage(@NonNull Predicate<String> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowedPackages = this.mAllowedPackages.or(predicate);
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowComponent(@NonNull final ComponentName componentName) {
+            Preconditions.checkNotNull(componentName);
+            Objects.requireNonNull(componentName);
+            return allowComponent(new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda18
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    return componentName.equals((ComponentName) obj);
+                }
+            });
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowComponent(@NonNull Predicate<ComponentName> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowSomeComponents = true;
+            this.mAllowedComponents = this.mAllowedComponents.or(predicate);
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowComponentWithPackage(@NonNull final String str) {
+            Preconditions.checkNotNull(str);
+            return allowComponent(new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda15
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    boolean lambda$allowComponentWithPackage$9;
+                    lambda$allowComponentWithPackage$9 = IntentSanitizer.Builder.lambda$allowComponentWithPackage$9(str, (ComponentName) obj);
+                    return lambda$allowComponentWithPackage$9;
+                }
+            });
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$allowComponentWithPackage$9(String str, ComponentName componentName) {
+            return str.equals(componentName.getPackageName());
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowAnyComponent() {
+            this.mAllowAnyComponent = true;
+            this.mAllowedComponents = new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda13
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    boolean lambda$allowAnyComponent$10;
+                    lambda$allowAnyComponent$10 = IntentSanitizer.Builder.lambda$allowAnyComponent$10((ComponentName) obj);
+                    return lambda$allowAnyComponent$10;
+                }
+            };
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowClipDataUriWithAuthority(@NonNull final String str) {
+            Preconditions.checkNotNull(str);
+            return allowClipDataUri(new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda10
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    boolean lambda$allowClipDataUriWithAuthority$11;
+                    lambda$allowClipDataUriWithAuthority$11 = IntentSanitizer.Builder.lambda$allowClipDataUriWithAuthority$11(str, (Uri) obj);
+                    return lambda$allowClipDataUriWithAuthority$11;
+                }
+            });
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$allowClipDataUriWithAuthority$11(String str, Uri uri) {
+            return str.equals(uri.getAuthority());
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowClipDataUri(@NonNull Predicate<Uri> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowedClipDataUri = this.mAllowedClipDataUri.or(predicate);
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowClipData(@NonNull Predicate<ClipData> predicate) {
+            Preconditions.checkNotNull(predicate);
+            this.mAllowedClipData = this.mAllowedClipData.or(predicate);
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowExtra(@NonNull String str, @NonNull Class<?> cls) {
+            return allowExtra(str, cls, new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda1
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    boolean lambda$allowExtra$12;
+                    lambda$allowExtra$12 = IntentSanitizer.Builder.lambda$allowExtra$12(obj);
+                    return lambda$allowExtra$12;
+                }
+            });
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public <T> Builder allowExtra(@NonNull String str, @NonNull final Class<T> cls, @NonNull 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$$ExternalSyntheticLambda14
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    boolean lambda$allowExtra$13;
+                    lambda$allowExtra$13 = IntentSanitizer.Builder.lambda$allowExtra$13(cls, predicate, obj);
+                    return lambda$allowExtra$13;
+                }
+            });
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$allowExtra$13(Class cls, Predicate predicate, Object obj) {
+            return cls.isInstance(obj) && predicate.test(cls.cast(obj));
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowExtra(@NonNull String str, @NonNull 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 final boolean test(Object obj) {
+                        boolean lambda$allowExtra$14;
+                        lambda$allowExtra$14 = IntentSanitizer.Builder.lambda$allowExtra$14(obj);
+                        return lambda$allowExtra$14;
+                    }
+                };
+            }
+            this.mAllowedExtras.put(str, predicate2.or(predicate));
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowExtraStreamUriWithAuthority(@NonNull final String str) {
+            Preconditions.checkNotNull(str);
+            allowExtra("android.intent.extra.STREAM", Uri.class, new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda12
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    boolean lambda$allowExtraStreamUriWithAuthority$15;
+                    lambda$allowExtraStreamUriWithAuthority$15 = IntentSanitizer.Builder.lambda$allowExtraStreamUriWithAuthority$15(str, (Uri) obj);
+                    return lambda$allowExtraStreamUriWithAuthority$15;
+                }
+            });
+            return this;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$allowExtraStreamUriWithAuthority$15(String str, Uri uri) {
+            return str.equals(uri.getAuthority());
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowExtraStream(@NonNull Predicate<Uri> predicate) {
+            allowExtra("android.intent.extra.STREAM", Uri.class, predicate);
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowExtraOutput(@NonNull final String str) {
+            allowExtra("output", Uri.class, new Predicate() { // from class: androidx.core.content.IntentSanitizer$Builder$$ExternalSyntheticLambda17
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    boolean lambda$allowExtraOutput$16;
+                    lambda$allowExtraOutput$16 = IntentSanitizer.Builder.lambda$allowExtraOutput$16(str, (Uri) obj);
+                    return lambda$allowExtraOutput$16;
+                }
+            });
+            return this;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ boolean lambda$allowExtraOutput$16(String str, Uri uri) {
+            return str.equals(uri.getAuthority());
+        }
+
+        @NonNull
+        @SuppressLint({"BuilderSetStyle"})
+        public Builder allowExtraOutput(@NonNull Predicate<Uri> predicate) {
+            allowExtra("output", Uri.class, predicate);
+            return this;
+        }
+
+        @NonNull
+        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;
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:29:0x00be  */
+    /* JADX WARN: Removed duplicated region for block: B:31:0x00cd  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static void sanitizeClipData(@androidx.annotation.NonNull 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 Lde
+        L14:
+            r9 = 0
+            r0 = 0
+            r1 = r9
+        L17:
+            int r2 = r7.getItemCount()
+            if (r0 >= r2) goto Ld9
+            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.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 L5c
+        L35:
+            java.lang.CharSequence r3 = r2.getText()
+            if (r3 == 0) goto L5b
+            java.lang.StringBuilder r3 = new java.lang.StringBuilder
+            r3.<init>()
+            java.lang.String r4 = "Item text cannot contain value. Item position: "
+            r3.append(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)
+        L5b:
+            r3 = r9
+        L5c:
+            java.lang.String r4 = ". URI: "
+            java.lang.String r5 = "Item URI is not allowed. Item position: "
+            if (r11 != 0) goto L85
+            android.net.Uri r6 = r2.getUri()
+            if (r6 == 0) goto Lb2
+            java.lang.StringBuilder r6 = new java.lang.StringBuilder
+            r6.<init>()
+            r6.append(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 Lb2
+        L85:
+            android.net.Uri r6 = r2.getUri()
+            if (r6 == 0) goto Lb4
+            android.net.Uri r6 = r2.getUri()
+            boolean r6 = r11.test(r6)
+            if (r6 == 0) goto L96
+            goto Lb4
+        L96:
+            java.lang.StringBuilder r6 = new java.lang.StringBuilder
+            r6.<init>()
+            r6.append(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)
+        Lb2:
+            r2 = r9
+            goto Lb8
+        Lb4:
+            android.net.Uri r2 = r2.getUri()
+        Lb8:
+            if (r3 != 0) goto Lbc
+            if (r2 == 0) goto Ld5
+        Lbc:
+            if (r1 != 0) goto Lcd
+            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 Ld5
+        Lcd:
+            android.content.ClipData$Item r4 = new android.content.ClipData$Item
+            r4.<init>(r3, r9, r2)
+            r1.addItem(r4)
+        Ld5:
+            int r0 = r0 + 1
+            goto L17
+        Ld9:
+            if (r1 == 0) goto Lde
+            r8.setClipData(r1)
+        Lde:
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.core.content.IntentSanitizer.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);
+    }
+
+    @RequiresApi(31)
+    public static class Api31Impl {
+        private Api31Impl() {
+        }
+
+        public static void checkOtherMembers(int i, ClipData.Item item, Consumer<String> consumer) {
+            if (item.getHtmlText() == null && item.getIntent() == null && item.getTextLinks() == null) {
+                return;
+            }
+            consumer.accept("ClipData item at position " + i + " contains htmlText, textLinks or intent: " + item);
+        }
+    }
+
+    @RequiresApi(29)
+    public static class Api29Impl {
+        private Api29Impl() {
+        }
+
+        public static Intent setIdentifier(Intent intent, String str) {
+            return intent.setIdentifier(str);
+        }
+
+        public static String getIdentifier(Intent intent) {
+            return intent.getIdentifier();
+        }
+    }
+}

decompiled/sources/androidx/core/content/LocusIdCompat.java

@@ -0,0 +1,88 @@
+package androidx.core.content;
+
+import android.content.LocusId;
+import android.os.Build;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.util.Preconditions;
+import com.ironsource.v8;
+
+/* loaded from: classes.dex */
+public final class LocusIdCompat {
+    private final String mId;
+    private final LocusId mWrapped;
+
+    @NonNull
+    public String getId() {
+        return this.mId;
+    }
+
+    @NonNull
+    @RequiresApi(29)
+    public LocusId toLocusId() {
+        return this.mWrapped;
+    }
+
+    public LocusIdCompat(@NonNull 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(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || LocusIdCompat.class != obj.getClass()) {
+            return false;
+        }
+        LocusIdCompat locusIdCompat = (LocusIdCompat) obj;
+        String str = this.mId;
+        if (str == null) {
+            return locusIdCompat.mId == null;
+        }
+        return str.equals(locusIdCompat.mId);
+    }
+
+    @NonNull
+    public String toString() {
+        return "LocusIdCompat[" + getSanitizedId() + v8.i.e;
+    }
+
+    @NonNull
+    @RequiresApi(29)
+    public static LocusIdCompat toLocusIdCompat(@NonNull LocusId locusId) {
+        Preconditions.checkNotNull(locusId, "locusId cannot be null");
+        return new LocusIdCompat((String) Preconditions.checkStringNotEmpty(Api29Impl.getId(locusId), "id cannot be empty"));
+    }
+
+    @NonNull
+    private String getSanitizedId() {
+        return this.mId.length() + "_chars";
+    }
+
+    @RequiresApi(29)
+    public static class Api29Impl {
+        private Api29Impl() {
+        }
+
+        @NonNull
+        public static LocusId create(@NonNull String str) {
+            return new LocusId(str);
+        }
+
+        @NonNull
+        public static String getId(@NonNull LocusId locusId) {
+            return locusId.getId();
+        }
+    }
+}

decompiled/sources/androidx/core/content/MimeTypeFilter.java

@@ -0,0 +1,78 @@
+package androidx.core.content;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.webkit.ProxyConfig;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+public final class MimeTypeFilter {
+    private MimeTypeFilter() {
+    }
+
+    private static boolean mimeTypeAgainstFilter(@NonNull String[] strArr, @NonNull 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 (ProxyConfig.MATCH_ALL_SCHEMES.equals(strArr2[0]) || strArr2[0].equals(strArr[0])) {
+            return ProxyConfig.MATCH_ALL_SCHEMES.equals(strArr2[1]) || strArr2[1].equals(strArr[1]);
+        }
+        return false;
+    }
+
+    public static boolean matches(@Nullable String str, @NonNull String str2) {
+        if (str == null) {
+            return false;
+        }
+        return mimeTypeAgainstFilter(str.split("/"), str2.split("/"));
+    }
+
+    @Nullable
+    public static String matches(@Nullable String str, @NonNull String[] strArr) {
+        if (str == null) {
+            return null;
+        }
+        String[] split = str.split("/");
+        for (String str2 : strArr) {
+            if (mimeTypeAgainstFilter(split, str2.split("/"))) {
+                return str2;
+            }
+        }
+        return null;
+    }
+
+    @Nullable
+    public static String matches(@Nullable String[] strArr, @NonNull String str) {
+        if (strArr == null) {
+            return null;
+        }
+        String[] split = str.split("/");
+        for (String str2 : strArr) {
+            if (mimeTypeAgainstFilter(str2.split("/"), split)) {
+                return str2;
+            }
+        }
+        return null;
+    }
+
+    @NonNull
+    public static String[] matchesMany(@Nullable String[] strArr, @NonNull 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()]);
+    }
+}

decompiled/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);
+}

decompiled/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);
+}

decompiled/sources/androidx/core/content/PackageManagerCompat.java

@@ -0,0 +1,114 @@
+package androidx.core.content;
+
+import android.annotation.SuppressLint;
+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.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+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 {
+
+    @SuppressLint({"ActionValue"})
+    public static final String ACTION_PERMISSION_REVOCATION_SETTINGS = "android.intent.action.AUTO_REVOKE_PERMISSIONS";
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static final String LOG_TAG = "PackageManagerCompat";
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public @interface UnusedAppRestrictionsStatus {
+    }
+
+    private PackageManagerCompat() {
+    }
+
+    @NonNull
+    public static ListenableFuture getUnusedAppRestrictionsStatus(@NonNull 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;
+        }
+        int i2 = Build.VERSION.SDK_INT;
+        if (i2 >= 31) {
+            if (Api30Impl.areUnusedAppRestrictionsEnabled(context)) {
+                create.set(Integer.valueOf(i >= 31 ? 5 : 4));
+            } else {
+                create.set(2);
+            }
+            return create;
+        }
+        if (i2 == 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;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static boolean areUnusedAppRestrictionsAvailable(@NonNull PackageManager packageManager) {
+        int i = Build.VERSION.SDK_INT;
+        return (i >= 30) || ((i < 30) && (getPermissionRevocationVerifierApp(packageManager) != null));
+    }
+
+    @Nullable
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public static String getPermissionRevocationVerifierApp(@NonNull 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;
+    }
+
+    @RequiresApi(30)
+    public static class Api30Impl {
+        private Api30Impl() {
+        }
+
+        public static boolean areUnusedAppRestrictionsEnabled(@NonNull Context context) {
+            return !context.getPackageManager().isAutoRevokeWhitelisted();
+        }
+    }
+}

decompiled/sources/androidx/core/content/PermissionChecker.java

@@ -0,0 +1,68 @@
+package androidx.core.content;
+
+import android.content.Context;
+import android.os.Binder;
+import android.os.Process;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+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)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public @interface PermissionResult {
+    }
+
+    private PermissionChecker() {
+    }
+
+    public static int checkPermission(@NonNull Context context, @NonNull String str, int i, int i2, @Nullable 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(@NonNull Context context, @NonNull String str) {
+        return checkPermission(context, str, Process.myPid(), Process.myUid(), context.getPackageName());
+    }
+
+    public static int checkCallingPermission(@NonNull Context context, @NonNull String str, @Nullable String str2) {
+        if (Binder.getCallingPid() == Process.myPid()) {
+            return -1;
+        }
+        return checkPermission(context, str, Binder.getCallingPid(), Binder.getCallingUid(), str2);
+    }
+
+    public static int checkCallingOrSelfPermission(@NonNull Context context, @NonNull String str) {
+        return checkPermission(context, str, Binder.getCallingPid(), Binder.getCallingUid(), Binder.getCallingPid() == Process.myPid() ? context.getPackageName() : null);
+    }
+}

decompiled/sources/androidx/core/content/SharedPreferencesCompat.java

@@ -0,0 +1,44 @@
+package androidx.core.content;
+
+import android.content.SharedPreferences;
+import androidx.annotation.NonNull;
+
+@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();
+
+        public static class Helper {
+            public void apply(@NonNull 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(@NonNull SharedPreferences.Editor editor) {
+            this.mHelper.apply(editor);
+        }
+    }
+
+    private SharedPreferencesCompat() {
+    }
+}

decompiled/sources/androidx/core/content/SharedPreferencesKt.java

@@ -0,0 +1,32 @@
+package androidx.core.content;
+
+import android.annotation.SuppressLint;
+import android.content.SharedPreferences;
+import kotlin.jvm.functions.Function1;
+
+/* loaded from: classes.dex */
+public final class SharedPreferencesKt {
+    @SuppressLint({"ApplySharedPref"})
+    public static final void edit(SharedPreferences sharedPreferences, boolean z, Function1 function1) {
+        SharedPreferences.Editor edit = sharedPreferences.edit();
+        function1.invoke(edit);
+        if (z) {
+            edit.commit();
+        } else {
+            edit.apply();
+        }
+    }
+
+    public static /* synthetic */ void edit$default(SharedPreferences sharedPreferences, boolean z, Function1 function1, int i, Object obj) {
+        if ((i & 1) != 0) {
+            z = false;
+        }
+        SharedPreferences.Editor edit = sharedPreferences.edit();
+        function1.invoke(edit);
+        if (z) {
+            edit.commit();
+        } else {
+            edit.apply();
+        }
+    }
+}

decompiled/sources/androidx/core/content/UnusedAppRestrictionsBackportCallback.java

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

decompiled/sources/androidx/core/content/UnusedAppRestrictionsBackportService.java

@@ -0,0 +1,35 @@
+package androidx.core.content;
+
+import android.annotation.SuppressLint;
+import android.app.Service;
+import android.content.Intent;
+import android.os.IBinder;
+import android.os.RemoteException;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportCallback;
+import androidx.core.app.unusedapprestrictions.IUnusedAppRestrictionsBackportService;
+
+/* loaded from: classes.dex */
+public abstract class UnusedAppRestrictionsBackportService extends Service {
+
+    @SuppressLint({"ActionValue"})
+    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(@Nullable IUnusedAppRestrictionsBackportCallback iUnusedAppRestrictionsBackportCallback) throws RemoteException {
+            if (iUnusedAppRestrictionsBackportCallback == null) {
+                return;
+            }
+            UnusedAppRestrictionsBackportService.this.isPermissionRevocationEnabled(new UnusedAppRestrictionsBackportCallback(iUnusedAppRestrictionsBackportCallback));
+        }
+    };
+
+    public abstract void isPermissionRevocationEnabled(@NonNull UnusedAppRestrictionsBackportCallback unusedAppRestrictionsBackportCallback);
+
+    @Override // android.app.Service
+    @Nullable
+    public IBinder onBind(@Nullable Intent intent) {
+        return this.mBinder;
+    }
+}

decompiled/sources/androidx/core/content/UnusedAppRestrictionsBackportServiceConnection.java

@@ -0,0 +1,81 @@
+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.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+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;
+
+    @NonNull
+    ResolvableFuture<Integer> mResultFuture;
+
+    @Nullable
+    @VisibleForTesting
+    IUnusedAppRestrictionsBackportService mUnusedAppRestrictionsService = null;
+    private boolean mHasBoundService = false;
+
+    @Override // android.content.ServiceConnection
+    public void onServiceDisconnected(ComponentName componentName) {
+        this.mUnusedAppRestrictionsService = null;
+    }
+
+    public UnusedAppRestrictionsBackportServiceConnection(@NonNull 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(@NonNull 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);
+                }
+            }
+        };
+    }
+}

decompiled/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() {
+    }
+}

decompiled/sources/androidx/core/content/UriMatcherCompat.java

@@ -0,0 +1,29 @@
+package androidx.core.content;
+
+import android.content.UriMatcher;
+import android.net.Uri;
+import androidx.annotation.NonNull;
+import androidx.core.util.Predicate;
+
+/* loaded from: classes.dex */
+public class UriMatcherCompat {
+    private UriMatcherCompat() {
+    }
+
+    @NonNull
+    public static Predicate<Uri> asPredicate(@NonNull final UriMatcher uriMatcher) {
+        return new Predicate() { // from class: androidx.core.content.UriMatcherCompat$$ExternalSyntheticLambda0
+            @Override // androidx.core.util.Predicate
+            public final boolean test(Object obj) {
+                boolean lambda$asPredicate$0;
+                lambda$asPredicate$0 = UriMatcherCompat.lambda$asPredicate$0(uriMatcher, (Uri) obj);
+                return lambda$asPredicate$0;
+            }
+        };
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static /* synthetic */ boolean lambda$asPredicate$0(UriMatcher uriMatcher, Uri uri) {
+        return uriMatcher.match(uri) != -1;
+    }
+}

decompiled/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() {
+    }
+}

decompiled/sources/androidx/core/content/pm/PackageInfoCompat$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.core.content.pm;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class PackageInfoCompat$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/core/content/pm/PackageInfoCompat.java

@@ -0,0 +1,156 @@
+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 androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.Size;
+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(@NonNull PackageInfo packageInfo) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.getLongVersionCode(packageInfo);
+        }
+        return packageInfo.versionCode;
+    }
+
+    @NonNull
+    public static List<Signature> getSignatures(@NonNull PackageManager packageManager, @NonNull 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(@NonNull PackageManager packageManager, @NonNull String str, @NonNull @Size(min = 1) 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(@NonNull byte[][] bArr, @NonNull 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() {
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static boolean hasSigningCertificate(@NonNull PackageManager packageManager, @NonNull String str, @NonNull byte[] bArr, int i) {
+            return packageManager.hasSigningCertificate(str, bArr, i);
+        }
+
+        public static boolean hasMultipleSigners(@NonNull SigningInfo signingInfo) {
+            return signingInfo.hasMultipleSigners();
+        }
+
+        @Nullable
+        public static Signature[] getApkContentsSigners(@NonNull SigningInfo signingInfo) {
+            return signingInfo.getApkContentsSigners();
+        }
+
+        @Nullable
+        public static Signature[] getSigningCertificateHistory(@NonNull SigningInfo signingInfo) {
+            return signingInfo.getSigningCertificateHistory();
+        }
+
+        public static long getLongVersionCode(PackageInfo packageInfo) {
+            return packageInfo.getLongVersionCode();
+        }
+    }
+}

decompiled/sources/androidx/core/content/pm/PermissionInfoCompat.java

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

decompiled/sources/androidx/core/content/pm/ShortcutInfoChangeListener.java

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

decompiled/sources/androidx/core/content/pm/ShortcutInfoCompat$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.core.content.pm;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ShortcutInfoCompat$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/core/content/pm/ShortcutInfoCompat$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.core.content.pm;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ShortcutInfoCompat$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/core/content/pm/ShortcutInfoCompat$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.core.content.pm;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ShortcutInfoCompat$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/core/content/pm/ShortcutInfoCompat$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,5 @@
+package androidx.core.content.pm;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ShortcutInfoCompat$$ExternalSyntheticApiModelOutline3 {
+}

decompiled/sources/androidx/core/content/pm/ShortcutInfoCompat$Builder$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.core.content.pm;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ShortcutInfoCompat$Builder$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/core/content/pm/ShortcutInfoCompat$Builder$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.core.content.pm;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ShortcutInfoCompat$Builder$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/core/content/pm/ShortcutInfoCompat.java

@@ -0,0 +1,677 @@
+package androidx.core.content.pm;
+
+import android.annotation.SuppressLint;
+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.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.collection.ArraySet;
+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;
+
+    @Nullable
+    LocusIdCompat mLocusId;
+    CharSequence mLongLabel;
+    String mPackageName;
+    Person[] mPersons;
+    int mRank;
+    Bundle mTransientExtras;
+    UserHandle mUser;
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public @interface Surface {
+    }
+
+    @Nullable
+    public ComponentName getActivity() {
+        return this.mActivity;
+    }
+
+    @Nullable
+    public Set<String> getCategories() {
+        return this.mCategories;
+    }
+
+    @Nullable
+    public CharSequence getDisabledMessage() {
+        return this.mDisabledMessage;
+    }
+
+    public int getDisabledReason() {
+        return this.mDisabledReason;
+    }
+
+    public int getExcludedFromSurfaces() {
+        return this.mExcludedSurfaces;
+    }
+
+    @Nullable
+    public PersistableBundle getExtras() {
+        return this.mExtras;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public IconCompat getIcon() {
+        return this.mIcon;
+    }
+
+    @NonNull
+    public String getId() {
+        return this.mId;
+    }
+
+    public long getLastChangedTimestamp() {
+        return this.mLastChangedTimestamp;
+    }
+
+    @Nullable
+    public LocusIdCompat getLocusId() {
+        return this.mLocusId;
+    }
+
+    @Nullable
+    public CharSequence getLongLabel() {
+        return this.mLongLabel;
+    }
+
+    @NonNull
+    public String getPackage() {
+        return this.mPackageName;
+    }
+
+    public int getRank() {
+        return this.mRank;
+    }
+
+    @NonNull
+    public CharSequence getShortLabel() {
+        return this.mLabel;
+    }
+
+    @Nullable
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public Bundle getTransientExtras() {
+        return this.mTransientExtras;
+    }
+
+    @Nullable
+    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;
+    }
+
+    @RequiresApi(25)
+    public ShortcutInfo toShortcutInfo() {
+        ShortcutInfo.Builder intents = new ShortcutInfo.Builder(this.mContext, this.mId).setShortLabel(this.mLabel).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());
+        }
+        if (Build.VERSION.SDK_INT >= 33) {
+            Api33Impl.setExcludedFromSurfaces(intents, this.mExcludedSurfaces);
+        }
+        return intents.build();
+    }
+
+    @RequiresApi(22)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    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();
+                sb.append(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;
+    }
+
+    public 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;
+    }
+
+    @NonNull
+    public Intent getIntent() {
+        return this.mIntents[r0.length - 1];
+    }
+
+    @NonNull
+    public Intent[] getIntents() {
+        Intent[] intentArr = this.mIntents;
+        return (Intent[]) Arrays.copyOf(intentArr, intentArr.length);
+    }
+
+    @VisibleForTesting
+    @Nullable
+    @RequiresApi(25)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static Person[] getPersonsFromExtra(@NonNull 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();
+            sb.append(EXTRA_PERSON_);
+            int i3 = i2 + 1;
+            sb.append(i3);
+            personArr[i2] = Person.fromPersistableBundle(persistableBundle.getPersistableBundle(sb.toString()));
+            i2 = i3;
+        }
+        return personArr;
+    }
+
+    @RequiresApi(25)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    @VisibleForTesting
+    public static boolean getLongLivedFromExtra(@Nullable PersistableBundle persistableBundle) {
+        if (persistableBundle == null || !persistableBundle.containsKey(EXTRA_LONG_LIVED)) {
+            return false;
+        }
+        return persistableBundle.getBoolean(EXTRA_LONG_LIVED);
+    }
+
+    @RequiresApi(25)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static List<ShortcutInfoCompat> fromShortcuts(@NonNull Context context, @NonNull List<ShortcutInfo> list) {
+        ArrayList arrayList = new ArrayList(list.size());
+        Iterator<ShortcutInfo> it = list.iterator();
+        while (it.hasNext()) {
+            arrayList.add(new Builder(context, it.next()).build());
+        }
+        return arrayList;
+    }
+
+    @Nullable
+    @RequiresApi(25)
+    public static LocusIdCompat getLocusId(@NonNull ShortcutInfo shortcutInfo) {
+        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);
+        }
+        return getLocusIdFromExtra(shortcutInfo.getExtras());
+    }
+
+    @Nullable
+    @RequiresApi(25)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    private static LocusIdCompat getLocusIdFromExtra(@Nullable 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;
+
+        @NonNull
+        public Builder setIsConversation() {
+            this.mIsConversation = true;
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"MissingGetterMatchingBuilder"})
+        public Builder setSliceUri(@NonNull Uri uri) {
+            this.mSliceUri = uri;
+            return this;
+        }
+
+        public Builder(@NonNull Context context, @NonNull String str) {
+            ShortcutInfoCompat shortcutInfoCompat = new ShortcutInfoCompat();
+            this.mInfo = shortcutInfoCompat;
+            shortcutInfoCompat.mContext = context;
+            shortcutInfoCompat.mId = str;
+        }
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+        public Builder(@NonNull ShortcutInfoCompat shortcutInfoCompat) {
+            ShortcutInfoCompat shortcutInfoCompat2 = new ShortcutInfoCompat();
+            this.mInfo = shortcutInfoCompat2;
+            shortcutInfoCompat2.mContext = shortcutInfoCompat.mContext;
+            shortcutInfoCompat2.mId = shortcutInfoCompat.mId;
+            shortcutInfoCompat2.mPackageName = shortcutInfoCompat.mPackageName;
+            Intent[] intentArr = shortcutInfoCompat.mIntents;
+            shortcutInfoCompat2.mIntents = (Intent[]) Arrays.copyOf(intentArr, intentArr.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;
+            Person[] personArr = shortcutInfoCompat.mPersons;
+            if (personArr != null) {
+                shortcutInfoCompat2.mPersons = (Person[]) Arrays.copyOf(personArr, personArr.length);
+            }
+            if (shortcutInfoCompat.mCategories != null) {
+                shortcutInfoCompat2.mCategories = new HashSet(shortcutInfoCompat.mCategories);
+            }
+            PersistableBundle persistableBundle = shortcutInfoCompat.mExtras;
+            if (persistableBundle != null) {
+                shortcutInfoCompat2.mExtras = persistableBundle;
+            }
+            shortcutInfoCompat2.mExcludedSurfaces = shortcutInfoCompat.mExcludedSurfaces;
+        }
+
+        @RequiresApi(25)
+        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+        public Builder(@NonNull Context context, @NonNull ShortcutInfo shortcutInfo) {
+            boolean isCached;
+            int disabledReason;
+            ShortcutInfoCompat shortcutInfoCompat = new ShortcutInfoCompat();
+            this.mInfo = shortcutInfoCompat;
+            shortcutInfoCompat.mContext = context;
+            shortcutInfoCompat.mId = shortcutInfo.getId();
+            shortcutInfoCompat.mPackageName = shortcutInfo.getPackage();
+            Intent[] intents = shortcutInfo.getIntents();
+            shortcutInfoCompat.mIntents = (Intent[]) Arrays.copyOf(intents, intents.length);
+            shortcutInfoCompat.mActivity = shortcutInfo.getActivity();
+            shortcutInfoCompat.mLabel = shortcutInfo.getShortLabel();
+            shortcutInfoCompat.mLongLabel = shortcutInfo.getLongLabel();
+            shortcutInfoCompat.mDisabledMessage = shortcutInfo.getDisabledMessage();
+            int i = Build.VERSION.SDK_INT;
+            if (i >= 28) {
+                disabledReason = shortcutInfo.getDisabledReason();
+                shortcutInfoCompat.mDisabledReason = disabledReason;
+            } else {
+                shortcutInfoCompat.mDisabledReason = shortcutInfo.isEnabled() ? 0 : 3;
+            }
+            shortcutInfoCompat.mCategories = shortcutInfo.getCategories();
+            shortcutInfoCompat.mPersons = ShortcutInfoCompat.getPersonsFromExtra(shortcutInfo.getExtras());
+            shortcutInfoCompat.mUser = shortcutInfo.getUserHandle();
+            shortcutInfoCompat.mLastChangedTimestamp = shortcutInfo.getLastChangedTimestamp();
+            if (i >= 30) {
+                isCached = shortcutInfo.isCached();
+                shortcutInfoCompat.mIsCached = isCached;
+            }
+            shortcutInfoCompat.mIsDynamic = shortcutInfo.isDynamic();
+            shortcutInfoCompat.mIsPinned = shortcutInfo.isPinned();
+            shortcutInfoCompat.mIsDeclaredInManifest = shortcutInfo.isDeclaredInManifest();
+            shortcutInfoCompat.mIsImmutable = shortcutInfo.isImmutable();
+            shortcutInfoCompat.mIsEnabled = shortcutInfo.isEnabled();
+            shortcutInfoCompat.mHasKeyFieldsOnly = shortcutInfo.hasKeyFieldsOnly();
+            shortcutInfoCompat.mLocusId = ShortcutInfoCompat.getLocusId(shortcutInfo);
+            shortcutInfoCompat.mRank = shortcutInfo.getRank();
+            shortcutInfoCompat.mExtras = shortcutInfo.getExtras();
+        }
+
+        @NonNull
+        public Builder setShortLabel(@NonNull CharSequence charSequence) {
+            this.mInfo.mLabel = charSequence;
+            return this;
+        }
+
+        @NonNull
+        public Builder setLongLabel(@NonNull CharSequence charSequence) {
+            this.mInfo.mLongLabel = charSequence;
+            return this;
+        }
+
+        @NonNull
+        public Builder setDisabledMessage(@NonNull CharSequence charSequence) {
+            this.mInfo.mDisabledMessage = charSequence;
+            return this;
+        }
+
+        @NonNull
+        public Builder setIntent(@NonNull Intent intent) {
+            return setIntents(new Intent[]{intent});
+        }
+
+        @NonNull
+        public Builder setIntents(@NonNull Intent[] intentArr) {
+            this.mInfo.mIntents = intentArr;
+            return this;
+        }
+
+        @NonNull
+        public Builder setIcon(IconCompat iconCompat) {
+            this.mInfo.mIcon = iconCompat;
+            return this;
+        }
+
+        @NonNull
+        public Builder setLocusId(@Nullable LocusIdCompat locusIdCompat) {
+            this.mInfo.mLocusId = locusIdCompat;
+            return this;
+        }
+
+        @NonNull
+        public Builder setActivity(@NonNull ComponentName componentName) {
+            this.mInfo.mActivity = componentName;
+            return this;
+        }
+
+        @NonNull
+        public Builder setAlwaysBadged() {
+            this.mInfo.mIsAlwaysBadged = true;
+            return this;
+        }
+
+        @NonNull
+        public Builder setPerson(@NonNull Person person) {
+            return setPersons(new Person[]{person});
+        }
+
+        @NonNull
+        public Builder setPersons(@NonNull Person[] personArr) {
+            this.mInfo.mPersons = personArr;
+            return this;
+        }
+
+        @NonNull
+        public Builder setCategories(@NonNull Set<String> set) {
+            ArraySet arraySet = new ArraySet();
+            arraySet.addAll(set);
+            this.mInfo.mCategories = arraySet;
+            return this;
+        }
+
+        @NonNull
+        @Deprecated
+        public Builder setLongLived() {
+            this.mInfo.mIsLongLived = true;
+            return this;
+        }
+
+        @NonNull
+        public Builder setLongLived(boolean z) {
+            this.mInfo.mIsLongLived = z;
+            return this;
+        }
+
+        @NonNull
+        public Builder setExcludedFromSurfaces(int i) {
+            this.mInfo.mExcludedSurfaces = i;
+            return this;
+        }
+
+        @NonNull
+        public Builder setRank(int i) {
+            this.mInfo.mRank = i;
+            return this;
+        }
+
+        @NonNull
+        public Builder setExtras(@NonNull PersistableBundle persistableBundle) {
+            this.mInfo.mExtras = persistableBundle;
+            return this;
+        }
+
+        @NonNull
+        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+        public Builder setTransientExtras(@NonNull Bundle bundle) {
+            this.mInfo.mTransientExtras = (Bundle) Preconditions.checkNotNull(bundle);
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"MissingGetterMatchingBuilder"})
+        public Builder addCapabilityBinding(@NonNull String str) {
+            if (this.mCapabilityBindings == null) {
+                this.mCapabilityBindings = new HashSet();
+            }
+            this.mCapabilityBindings.add(str);
+            return this;
+        }
+
+        @NonNull
+        @SuppressLint({"MissingGetterMatchingBuilder"})
+        public Builder addCapabilityBinding(@NonNull String str, @NonNull String str2, @NonNull 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;
+        }
+
+        @NonNull
+        public ShortcutInfoCompat build() {
+            if (TextUtils.isEmpty(this.mInfo.mLabel)) {
+                throw new IllegalArgumentException("Shortcut must have a non-empty label");
+            }
+            ShortcutInfoCompat shortcutInfoCompat = this.mInfo;
+            Intent[] intentArr = shortcutInfoCompat.mIntents;
+            if (intentArr == null || intentArr.length == 0) {
+                throw new IllegalArgumentException("Shortcut must have an intent");
+            }
+            if (this.mIsConversation) {
+                if (shortcutInfoCompat.mLocusId == null) {
+                    shortcutInfoCompat.mLocusId = new LocusIdCompat(shortcutInfoCompat.mId);
+                }
+                this.mInfo.mIsLongLived = true;
+            }
+            if (this.mCapabilityBindings != null) {
+                ShortcutInfoCompat shortcutInfoCompat2 = this.mInfo;
+                if (shortcutInfoCompat2.mCategories == null) {
+                    shortcutInfoCompat2.mCategories = new HashSet();
+                }
+                this.mInfo.mCategories.addAll(this.mCapabilityBindings);
+            }
+            if (this.mCapabilityBindingParams != null) {
+                ShortcutInfoCompat shortcutInfoCompat3 = this.mInfo;
+                if (shortcutInfoCompat3.mExtras == null) {
+                    shortcutInfoCompat3.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) {
+                ShortcutInfoCompat shortcutInfoCompat4 = this.mInfo;
+                if (shortcutInfoCompat4.mExtras == null) {
+                    shortcutInfoCompat4.mExtras = new PersistableBundle();
+                }
+                this.mInfo.mExtras.putString(ShortcutInfoCompat.EXTRA_SLICE_URI, UriCompat.toSafeString(this.mSliceUri));
+            }
+            return this.mInfo;
+        }
+    }
+
+    @RequiresApi(33)
+    public static class Api33Impl {
+        private Api33Impl() {
+        }
+
+        public static void setExcludedFromSurfaces(@NonNull ShortcutInfo.Builder builder, int i) {
+            builder.setExcludedFromSurfaces(i);
+        }
+    }
+}

decompiled/sources/androidx/core/content/pm/ShortcutInfoCompatSaver.java

@@ -0,0 +1,55 @@
+package androidx.core.content.pm;
+
+import androidx.annotation.AnyThread;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.WorkerThread;
+import java.util.ArrayList;
+import java.util.List;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public abstract class ShortcutInfoCompatSaver<T> {
+    @AnyThread
+    public abstract T addShortcuts(List<ShortcutInfoCompat> list);
+
+    @AnyThread
+    public abstract T removeAllShortcuts();
+
+    @AnyThread
+    public abstract T removeShortcuts(List<String> list);
+
+    @WorkerThread
+    public List<ShortcutInfoCompat> getShortcuts() throws Exception {
+        return new ArrayList();
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    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);
+        }
+    }
+}

decompiled/sources/androidx/core/content/pm/ShortcutManagerCompat$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.core.content.pm;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ShortcutManagerCompat$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/core/content/pm/ShortcutManagerCompat$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.core.content.pm;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ShortcutManagerCompat$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/core/content/pm/ShortcutManagerCompat$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.core.content.pm;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ShortcutManagerCompat$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/core/content/pm/ShortcutManagerCompat.java

@@ -0,0 +1,481 @@
+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.util.DisplayMetrics;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+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 {
+
+    @VisibleForTesting
+    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;
+
+    @VisibleForTesting
+    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)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public @interface ShortcutMatchFlags {
+    }
+
+    @VisibleForTesting
+    public static List<ShortcutInfoChangeListener> getShortcutInfoChangeListeners() {
+        return sShortcutInfoChangeListeners;
+    }
+
+    @VisibleForTesting
+    public static void setShortcutInfoChangeListeners(List<ShortcutInfoChangeListener> list) {
+        sShortcutInfoChangeListeners = list;
+    }
+
+    @VisibleForTesting
+    public static void setShortcutInfoCompatSaver(ShortcutInfoCompatSaver<Void> shortcutInfoCompatSaver) {
+        sShortcutInfoCompatSaver = shortcutInfoCompatSaver;
+    }
+
+    private ShortcutManagerCompat() {
+    }
+
+    public static boolean isRequestPinShortcutSupported(@NonNull Context context) {
+        return ((ShortcutManager) context.getSystemService(ShortcutManager.class)).isRequestPinShortcutSupported();
+    }
+
+    public static boolean requestPinShortcut(@NonNull Context context, @NonNull ShortcutInfoCompat shortcutInfoCompat, @Nullable IntentSender intentSender) {
+        if (Build.VERSION.SDK_INT > 32 || !shortcutInfoCompat.isExcludedFromSurfaces(1)) {
+            return ((ShortcutManager) context.getSystemService(ShortcutManager.class)).requestPinShortcut(shortcutInfoCompat.toShortcutInfo(), intentSender);
+        }
+        return false;
+    }
+
+    /* renamed from: androidx.core.content.pm.ShortcutManagerCompat$1, reason: invalid class name */
+    public class AnonymousClass1 extends BroadcastReceiver {
+        final /* synthetic */ IntentSender val$callback;
+
+        public AnonymousClass1(IntentSender intentSender) {
+            this.val$callback = intentSender;
+        }
+
+        @Override // android.content.BroadcastReceiver
+        public void onReceive(Context context, Intent intent) {
+            try {
+                this.val$callback.sendIntent(context, 0, null, null, null);
+            } catch (IntentSender.SendIntentException unused) {
+            }
+        }
+    }
+
+    @NonNull
+    public static Intent createShortcutResultIntent(@NonNull Context context, @NonNull ShortcutInfoCompat shortcutInfoCompat) {
+        Intent createShortcutResultIntent = ((ShortcutManager) context.getSystemService(ShortcutManager.class)).createShortcutResultIntent(shortcutInfoCompat.toShortcutInfo());
+        if (createShortcutResultIntent == null) {
+            createShortcutResultIntent = new Intent();
+        }
+        return shortcutInfoCompat.addToIntent(createShortcutResultIntent);
+    }
+
+    @NonNull
+    public static List<ShortcutInfoCompat> getShortcuts(@NonNull Context context, int i) {
+        List shortcuts;
+        if (Build.VERSION.SDK_INT >= 30) {
+            shortcuts = ((ShortcutManager) context.getSystemService(ShortcutManager.class)).getShortcuts(i);
+            return ShortcutInfoCompat.fromShortcuts(context, shortcuts);
+        }
+        ShortcutManager shortcutManager = (ShortcutManager) context.getSystemService(ShortcutManager.class);
+        ArrayList arrayList = new ArrayList();
+        if ((i & 1) != 0) {
+            arrayList.addAll(shortcutManager.getManifestShortcuts());
+        }
+        if ((i & 2) != 0) {
+            arrayList.addAll(shortcutManager.getDynamicShortcuts());
+        }
+        if ((i & 4) != 0) {
+            arrayList.addAll(shortcutManager.getPinnedShortcuts());
+        }
+        return ShortcutInfoCompat.fromShortcuts(context, arrayList);
+    }
+
+    public static boolean addDynamicShortcuts(@NonNull Context context, @NonNull List<ShortcutInfoCompat> list) {
+        List<ShortcutInfoCompat> removeShortcutsExcludedFromSurface = removeShortcutsExcludedFromSurface(list, 1);
+        if (Build.VERSION.SDK_INT <= 29) {
+            convertUriIconsToBitmapIcons(context, removeShortcutsExcludedFromSurface);
+        }
+        ArrayList arrayList = new ArrayList();
+        Iterator<ShortcutInfoCompat> it = removeShortcutsExcludedFromSurface.iterator();
+        while (it.hasNext()) {
+            arrayList.add(it.next().toShortcutInfo());
+        }
+        if (!((ShortcutManager) context.getSystemService(ShortcutManager.class)).addDynamicShortcuts(arrayList)) {
+            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(@NonNull Context context) {
+        Preconditions.checkNotNull(context);
+        return ((ShortcutManager) context.getSystemService(ShortcutManager.class)).getMaxShortcutCountPerActivity();
+    }
+
+    public static boolean isRateLimitingActive(@NonNull Context context) {
+        Preconditions.checkNotNull(context);
+        return ((ShortcutManager) context.getSystemService(ShortcutManager.class)).isRateLimitingActive();
+    }
+
+    public static int getIconMaxWidth(@NonNull Context context) {
+        Preconditions.checkNotNull(context);
+        return ((ShortcutManager) context.getSystemService(ShortcutManager.class)).getIconMaxWidth();
+    }
+
+    public static int getIconMaxHeight(@NonNull Context context) {
+        Preconditions.checkNotNull(context);
+        return ((ShortcutManager) context.getSystemService(ShortcutManager.class)).getIconMaxHeight();
+    }
+
+    public static void reportShortcutUsed(@NonNull Context context, @NonNull String str) {
+        Preconditions.checkNotNull(context);
+        Preconditions.checkNotNull(str);
+        ((ShortcutManager) context.getSystemService(ShortcutManager.class)).reportShortcutUsed(str);
+        Iterator<ShortcutInfoChangeListener> it = getShortcutInfoListeners(context).iterator();
+        while (it.hasNext()) {
+            it.next().onShortcutUsageReported(Collections.singletonList(str));
+        }
+    }
+
+    public static boolean setDynamicShortcuts(@NonNull Context context, @NonNull List<ShortcutInfoCompat> list) {
+        Preconditions.checkNotNull(context);
+        Preconditions.checkNotNull(list);
+        List<ShortcutInfoCompat> removeShortcutsExcludedFromSurface = removeShortcutsExcludedFromSurface(list, 1);
+        ArrayList arrayList = new ArrayList(removeShortcutsExcludedFromSurface.size());
+        Iterator<ShortcutInfoCompat> it = removeShortcutsExcludedFromSurface.iterator();
+        while (it.hasNext()) {
+            arrayList.add(it.next().toShortcutInfo());
+        }
+        if (!((ShortcutManager) context.getSystemService(ShortcutManager.class)).setDynamicShortcuts(arrayList)) {
+            return false;
+        }
+        getShortcutInfoSaverInstance(context).removeAllShortcuts();
+        getShortcutInfoSaverInstance(context).addShortcuts(removeShortcutsExcludedFromSurface);
+        for (ShortcutInfoChangeListener shortcutInfoChangeListener : getShortcutInfoListeners(context)) {
+            shortcutInfoChangeListener.onAllShortcutsRemoved();
+            shortcutInfoChangeListener.onShortcutAdded(list);
+        }
+        return true;
+    }
+
+    @NonNull
+    public static List<ShortcutInfoCompat> getDynamicShortcuts(@NonNull Context context) {
+        List<ShortcutInfo> dynamicShortcuts = ((ShortcutManager) context.getSystemService(ShortcutManager.class)).getDynamicShortcuts();
+        ArrayList arrayList = new ArrayList(dynamicShortcuts.size());
+        Iterator<ShortcutInfo> it = dynamicShortcuts.iterator();
+        while (it.hasNext()) {
+            arrayList.add(new ShortcutInfoCompat.Builder(context, it.next()).build());
+        }
+        return arrayList;
+    }
+
+    public static boolean updateShortcuts(@NonNull Context context, @NonNull List<ShortcutInfoCompat> list) {
+        List<ShortcutInfoCompat> removeShortcutsExcludedFromSurface = removeShortcutsExcludedFromSurface(list, 1);
+        if (Build.VERSION.SDK_INT <= 29) {
+            convertUriIconsToBitmapIcons(context, removeShortcutsExcludedFromSurface);
+        }
+        ArrayList arrayList = new ArrayList();
+        Iterator<ShortcutInfoCompat> it = removeShortcutsExcludedFromSurface.iterator();
+        while (it.hasNext()) {
+            arrayList.add(it.next().toShortcutInfo());
+        }
+        if (!((ShortcutManager) context.getSystemService(ShortcutManager.class)).updateShortcuts(arrayList)) {
+            return false;
+        }
+        getShortcutInfoSaverInstance(context).addShortcuts(removeShortcutsExcludedFromSurface);
+        Iterator<ShortcutInfoChangeListener> it2 = getShortcutInfoListeners(context).iterator();
+        while (it2.hasNext()) {
+            it2.next().onShortcutUpdated(list);
+        }
+        return true;
+    }
+
+    @VisibleForTesting
+    public static boolean convertUriIconToBitmapIcon(@NonNull Context context, @NonNull ShortcutInfoCompat shortcutInfoCompat) {
+        Bitmap decodeStream;
+        IconCompat createWithBitmap;
+        IconCompat iconCompat = shortcutInfoCompat.mIcon;
+        if (iconCompat == null) {
+            return false;
+        }
+        int i = iconCompat.mType;
+        if (i != 6 && i != 4) {
+            return true;
+        }
+        InputStream uriInputStream = iconCompat.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;
+    }
+
+    @VisibleForTesting
+    public static void convertUriIconsToBitmapIcons(@NonNull Context context, @NonNull List<ShortcutInfoCompat> list) {
+        for (ShortcutInfoCompat shortcutInfoCompat : new ArrayList(list)) {
+            if (!convertUriIconToBitmapIcon(context, shortcutInfoCompat)) {
+                list.remove(shortcutInfoCompat);
+            }
+        }
+    }
+
+    public static void disableShortcuts(@NonNull Context context, @NonNull List<String> list, @Nullable CharSequence charSequence) {
+        ((ShortcutManager) context.getSystemService(ShortcutManager.class)).disableShortcuts(list, charSequence);
+        getShortcutInfoSaverInstance(context).removeShortcuts(list);
+        Iterator<ShortcutInfoChangeListener> it = getShortcutInfoListeners(context).iterator();
+        while (it.hasNext()) {
+            it.next().onShortcutRemoved(list);
+        }
+    }
+
+    public static void enableShortcuts(@NonNull Context context, @NonNull List<ShortcutInfoCompat> list) {
+        List<ShortcutInfoCompat> removeShortcutsExcludedFromSurface = removeShortcutsExcludedFromSurface(list, 1);
+        ArrayList arrayList = new ArrayList(list.size());
+        Iterator<ShortcutInfoCompat> it = removeShortcutsExcludedFromSurface.iterator();
+        while (it.hasNext()) {
+            arrayList.add(it.next().mId);
+        }
+        ((ShortcutManager) context.getSystemService(ShortcutManager.class)).enableShortcuts(arrayList);
+        getShortcutInfoSaverInstance(context).addShortcuts(removeShortcutsExcludedFromSurface);
+        Iterator<ShortcutInfoChangeListener> it2 = getShortcutInfoListeners(context).iterator();
+        while (it2.hasNext()) {
+            it2.next().onShortcutAdded(list);
+        }
+    }
+
+    public static void removeDynamicShortcuts(@NonNull Context context, @NonNull List<String> list) {
+        ((ShortcutManager) context.getSystemService(ShortcutManager.class)).removeDynamicShortcuts(list);
+        getShortcutInfoSaverInstance(context).removeShortcuts(list);
+        Iterator<ShortcutInfoChangeListener> it = getShortcutInfoListeners(context).iterator();
+        while (it.hasNext()) {
+            it.next().onShortcutRemoved(list);
+        }
+    }
+
+    public static void removeAllDynamicShortcuts(@NonNull Context context) {
+        ((ShortcutManager) context.getSystemService(ShortcutManager.class)).removeAllDynamicShortcuts();
+        getShortcutInfoSaverInstance(context).removeAllShortcuts();
+        Iterator<ShortcutInfoChangeListener> it = getShortcutInfoListeners(context).iterator();
+        while (it.hasNext()) {
+            it.next().onAllShortcutsRemoved();
+        }
+    }
+
+    public static void removeLongLivedShortcuts(@NonNull Context context, @NonNull List<String> list) {
+        if (Build.VERSION.SDK_INT < 30) {
+            removeDynamicShortcuts(context, list);
+            return;
+        }
+        ((ShortcutManager) context.getSystemService(ShortcutManager.class)).removeLongLivedShortcuts(list);
+        getShortcutInfoSaverInstance(context).removeShortcuts(list);
+        Iterator<ShortcutInfoChangeListener> it = getShortcutInfoListeners(context).iterator();
+        while (it.hasNext()) {
+            it.next().onShortcutRemoved(list);
+        }
+    }
+
+    public static boolean pushDynamicShortcut(@NonNull Context context, @NonNull ShortcutInfoCompat shortcutInfoCompat) {
+        Preconditions.checkNotNull(context);
+        Preconditions.checkNotNull(shortcutInfoCompat);
+        int i = Build.VERSION.SDK_INT;
+        if (i <= 32 && 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 (i <= 29) {
+            convertUriIconToBitmapIcon(context, shortcutInfoCompat);
+        }
+        if (i >= 30) {
+            ((ShortcutManager) context.getSystemService(ShortcutManager.class)).pushDynamicShortcut(shortcutInfoCompat.toShortcutInfo());
+        } else {
+            ShortcutManager shortcutManager = (ShortcutManager) context.getSystemService(ShortcutManager.class);
+            if (shortcutManager.isRateLimitingActive()) {
+                return false;
+            }
+            List<ShortcutInfo> dynamicShortcuts = shortcutManager.getDynamicShortcuts();
+            if (dynamicShortcuts.size() >= maxShortcutCountPerActivity) {
+                shortcutManager.removeDynamicShortcuts(Arrays.asList(Api25Impl.getShortcutInfoWithLowestRank(dynamicShortcuts)));
+            }
+            shortcutManager.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(@NonNull 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(@NonNull Context context, boolean z) {
+        ActivityManager activityManager = (ActivityManager) context.getSystemService("activity");
+        int max = Math.max(1, activityManager == null || activityManager.isLowRamDevice() ? 48 : DEFAULT_MAX_ICON_DIMENSION_DP);
+        DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
+        return (int) (max * ((z ? displayMetrics.xdpi : displayMetrics.ydpi) / 160.0f));
+    }
+
+    private static ShortcutInfoCompatSaver<?> getShortcutInfoSaverInstance(Context context) {
+        if (sShortcutInfoCompatSaver == null) {
+            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;
+    }
+
+    @NonNull
+    private static List<ShortcutInfoCompat> removeShortcutsExcludedFromSurface(@NonNull List<ShortcutInfoCompat> list, int i) {
+        Objects.requireNonNull(list);
+        if (Build.VERSION.SDK_INT > 32) {
+            return list;
+        }
+        ArrayList arrayList = new ArrayList(list);
+        for (ShortcutInfoCompat shortcutInfoCompat : list) {
+            if (shortcutInfoCompat.isExcludedFromSurfaces(i)) {
+                arrayList.remove(shortcutInfoCompat);
+            }
+        }
+        return arrayList;
+    }
+
+    @RequiresApi(25)
+    public static class Api25Impl {
+        private Api25Impl() {
+        }
+
+        public static String getShortcutInfoWithLowestRank(@NonNull 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;
+        }
+    }
+}

decompiled/sources/androidx/core/content/pm/ShortcutXmlParser.java

@@ -0,0 +1,116 @@
+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 androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.annotation.WorkerThread;
+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;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* 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;
+
+    @NonNull
+    @WorkerThread
+    public static List<String> getShortcutIds(@NonNull Context context) {
+        if (sShortcutIds == null) {
+            synchronized (GET_INSTANCE_LOCK) {
+                try {
+                    if (sShortcutIds == null) {
+                        sShortcutIds = new ArrayList<>();
+                        sShortcutIds.addAll(parseShortcutIds(context));
+                    }
+                } finally {
+                }
+            }
+        }
+        return sShortcutIds;
+    }
+
+    private ShortcutXmlParser() {
+    }
+
+    @NonNull
+    private static Set<String> parseShortcutIds(@NonNull 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;
+    }
+
+    @NonNull
+    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);
+    }
+
+    @NonNull
+    @VisibleForTesting
+    public static List<String> parseShortcutIds(@NonNull 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;
+    }
+}

decompiled/sources/androidx/core/content/res/CamColor.java

@@ -0,0 +1,287 @@
+package androidx.core.content.res;
+
+import androidx.annotation.ColorInt;
+import androidx.annotation.FloatRange;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.Size;
+import androidx.core.graphics.ColorUtils;
+import kotlin.jvm.internal.DoubleCompanionObject;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public 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;
+
+    @FloatRange(from = DoubleCompanionObject.NEGATIVE_INFINITY, fromInclusive = false, to = DoubleCompanionObject.POSITIVE_INFINITY, toInclusive = false)
+    public float getAStar() {
+        return this.mAstar;
+    }
+
+    @FloatRange(from = DoubleCompanionObject.NEGATIVE_INFINITY, fromInclusive = false, to = DoubleCompanionObject.POSITIVE_INFINITY, toInclusive = false)
+    public float getBStar() {
+        return this.mBstar;
+    }
+
+    @FloatRange(from = 0.0d, to = DoubleCompanionObject.POSITIVE_INFINITY, toInclusive = false)
+    public float getChroma() {
+        return this.mChroma;
+    }
+
+    @FloatRange(from = 0.0d, to = 360.0d, toInclusive = false)
+    public float getHue() {
+        return this.mHue;
+    }
+
+    @FloatRange(from = 0.0d, to = 100.0d)
+    public float getJ() {
+        return this.mJ;
+    }
+
+    @FloatRange(from = 0.0d, to = 100.0d)
+    public float getJStar() {
+        return this.mJstar;
+    }
+
+    @FloatRange(from = 0.0d, to = DoubleCompanionObject.POSITIVE_INFINITY, toInclusive = false)
+    public float getM() {
+        return this.mM;
+    }
+
+    @FloatRange(from = 0.0d, to = DoubleCompanionObject.POSITIVE_INFINITY, toInclusive = false)
+    public float getQ() {
+        return this.mQ;
+    }
+
+    @FloatRange(from = 0.0d, to = DoubleCompanionObject.POSITIVE_INFINITY, toInclusive = false)
+    public float getS() {
+        return this.mS;
+    }
+
+    public 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;
+    }
+
+    public static int toColor(@FloatRange(from = 0.0d, to = 360.0d) float f, @FloatRange(from = 0.0d, to = Double.POSITIVE_INFINITY, toInclusive = false) float f2, @FloatRange(from = 0.0d, to = 100.0d) float f3) {
+        return toColor(f, f2, f3, ViewingConditions.DEFAULT);
+    }
+
+    @NonNull
+    public static CamColor fromColor(@ColorInt int i) {
+        float[] fArr = new float[7];
+        float[] fArr2 = new float[3];
+        fromColorInViewingConditions(i, ViewingConditions.DEFAULT, fArr, fArr2);
+        return new CamColor(fArr2[0], fArr2[1], fArr[0], fArr[1], fArr[2], fArr[3], fArr[4], fArr[5], fArr[6]);
+    }
+
+    public static void getM3HCTfromColor(@ColorInt int i, @NonNull @Size(3) float[] fArr) {
+        fromColorInViewingConditions(i, ViewingConditions.DEFAULT, null, fArr);
+        fArr[2] = CamUtils.lStarFromInt(i);
+    }
+
+    public static void fromColorInViewingConditions(@ColorInt int i, @NonNull ViewingConditions viewingConditions, @Nullable @Size(7) float[] fArr, @NonNull @Size(3) float[] fArr2) {
+        CamUtils.xyzFromInt(i, fArr2);
+        float[][] fArr3 = CamUtils.XYZ_TO_CAM16RGB;
+        float f = fArr2[0];
+        float[] fArr4 = fArr3[0];
+        float f2 = fArr4[0] * f;
+        float f3 = fArr2[1];
+        float f4 = f2 + (fArr4[1] * f3);
+        float f5 = fArr2[2];
+        float f6 = f4 + (fArr4[2] * f5);
+        float[] fArr5 = fArr3[1];
+        float f7 = (fArr5[0] * f) + (fArr5[1] * f3) + (fArr5[2] * f5);
+        float[] fArr6 = fArr3[2];
+        float f8 = (f * fArr6[0]) + (f3 * fArr6[1]) + (f5 * fArr6[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 = (3.1415927f * atan2) / 180.0f;
+        float pow4 = ((float) Math.pow((f16 * viewingConditions.getNbb()) / viewingConditions.getAw(), viewingConditions.getC() * viewingConditions.getZ())) * 100.0f;
+        float c = (4.0f / viewingConditions.getC()) * ((float) Math.sqrt(pow4 / 100.0f)) * (viewingConditions.getAw() + 4.0f) * viewingConditions.getFlRoot();
+        float sqrt = ((float) Math.sqrt(pow4 / 100.0d)) * ((float) Math.pow(1.64d - Math.pow(0.29d, viewingConditions.getN()), 0.73d)) * ((float) Math.pow((((((((float) (Math.cos((((((double) atan2) < 20.14d ? 360.0f + atan2 : atan2) * 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 flRoot = viewingConditions.getFlRoot() * sqrt;
+        float sqrt2 = ((float) Math.sqrt((r7 * viewingConditions.getC()) / (viewingConditions.getAw() + 4.0f))) * 50.0f;
+        float f18 = (1.7f * pow4) / ((0.007f * pow4) + DE_MAX);
+        float log = ((float) Math.log((0.0228f * flRoot) + DE_MAX)) * 43.85965f;
+        double d2 = f17;
+        float cos = ((float) Math.cos(d2)) * log;
+        float sin = log * ((float) Math.sin(d2));
+        fArr2[0] = atan2;
+        fArr2[1] = sqrt;
+        if (fArr != null) {
+            fArr[0] = pow4;
+            fArr[1] = c;
+            fArr[2] = flRoot;
+            fArr[3] = sqrt2;
+            fArr[4] = f18;
+            fArr[5] = cos;
+            fArr[6] = sin;
+        }
+    }
+
+    @NonNull
+    private static CamColor fromJch(@FloatRange(from = 0.0d, to = 100.0d) float f, @FloatRange(from = 0.0d, to = Double.POSITIVE_INFINITY, toInclusive = false) float f2, @FloatRange(from = 0.0d, to = 360.0d) float f3) {
+        return fromJchInFrame(f, f2, f3, ViewingConditions.DEFAULT);
+    }
+
+    @NonNull
+    private static CamColor fromJchInFrame(@FloatRange(from = 0.0d, to = 100.0d) float f, @FloatRange(from = 0.0d, to = Double.POSITIVE_INFINITY, toInclusive = false) float f2, @FloatRange(from = 0.0d, to = 360.0d) 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) + DE_MAX);
+        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)));
+    }
+
+    public float distance(@NonNull 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);
+    }
+
+    @ColorInt
+    public int viewedInSrgb() {
+        return viewed(ViewingConditions.DEFAULT);
+    }
+
+    @ColorInt
+    public int viewed(@NonNull 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]));
+    }
+
+    @ColorInt
+    public static int toColor(@FloatRange(from = 0.0d, to = 360.0d) float f, @FloatRange(from = 0.0d, to = Double.POSITIVE_INFINITY, toInclusive = false) float f2, @FloatRange(from = 0.0d, to = 100.0d) float f3, @NonNull 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);
+        CamColor camColor = null;
+        boolean z = true;
+        float f4 = 0.0f;
+        float f5 = f2;
+        while (Math.abs(f4 - f2) >= CHROMA_SEARCH_ENDPOINT) {
+            CamColor findCamByJ = findCamByJ(min, f5, f3);
+            if (!z) {
+                if (findCamByJ == null) {
+                    f2 = f5;
+                } else {
+                    f4 = f5;
+                    camColor = findCamByJ;
+                }
+                f5 = ((f2 - f4) / 2.0f) + f4;
+            } else {
+                if (findCamByJ != null) {
+                    return findCamByJ.viewed(viewingConditions);
+                }
+                f5 = ((f2 - f4) / 2.0f) + f4;
+                z = false;
+            }
+        }
+        if (camColor == null) {
+            return CamUtils.intFromLStar(f3);
+        }
+        return camColor.viewed(viewingConditions);
+    }
+
+    @Nullable
+    private static CamColor findCamByJ(@FloatRange(from = 0.0d, to = 360.0d) float f, @FloatRange(from = 0.0d, to = Double.POSITIVE_INFINITY, toInclusive = false) float f2, @FloatRange(from = 0.0d, to = 100.0d) float f3) {
+        float f4 = 100.0f;
+        float f5 = 1000.0f;
+        float f6 = 0.0f;
+        CamColor camColor = null;
+        float f7 = 1000.0f;
+        while (Math.abs(f6 - f4) > LIGHTNESS_SEARCH_ENDPOINT) {
+            float f8 = ((f4 - f6) / 2.0f) + f6;
+            int viewedInSrgb = fromJch(f8, f2, f).viewedInSrgb();
+            float lStarFromInt = CamUtils.lStarFromInt(viewedInSrgb);
+            float abs = Math.abs(f3 - lStarFromInt);
+            if (abs < DL_MAX) {
+                CamColor fromColor = fromColor(viewedInSrgb);
+                float distance = fromColor.distance(fromJch(fromColor.getJ(), fromColor.getChroma(), f));
+                if (distance <= DE_MAX) {
+                    camColor = fromColor;
+                    f5 = abs;
+                    f7 = distance;
+                }
+            }
+            if (f5 == 0.0f && f7 == 0.0f) {
+                break;
+            }
+            if (lStarFromInt < f3) {
+                f6 = f8;
+            } else {
+                f4 = f8;
+            }
+        }
+        return camColor;
+    }
+}

decompiled/sources/androidx/core/content/res/CamUtils.java

@@ -0,0 +1,79 @@
+package androidx.core.content.res;
+
+import android.graphics.Color;
+import androidx.annotation.NonNull;
+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}};
+
+    public static float lerp(float f, float f2, float f3) {
+        return f + ((f2 - f) * f3);
+    }
+
+    private CamUtils() {
+    }
+
+    public 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]);
+    }
+
+    public static float lStarFromInt(int i) {
+        return lStarFromY(yFromInt(i));
+    }
+
+    public 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;
+    }
+
+    public 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]);
+    }
+
+    public static void xyzFromInt(int i, @NonNull float[] fArr) {
+        float linearized = linearized(Color.red(i));
+        float linearized2 = linearized(Color.green(i));
+        float linearized3 = linearized(Color.blue(i));
+        float[][] fArr2 = SRGB_TO_XYZ;
+        float[] fArr3 = fArr2[0];
+        fArr[0] = (fArr3[0] * linearized) + (fArr3[1] * linearized2) + (fArr3[2] * linearized3);
+        float[] fArr4 = fArr2[1];
+        fArr[1] = (fArr4[0] * linearized) + (fArr4[1] * linearized2) + (fArr4[2] * linearized3);
+        float[] fArr5 = fArr2[2];
+        fArr[2] = (linearized * fArr5[0]) + (linearized2 * fArr5[1]) + (linearized3 * fArr5[2]);
+    }
+
+    public static float yFromLStar(float f) {
+        return (f > 8.0f ? (float) Math.pow((f + 16.0d) / 116.0d, 3.0d) : f / 903.2963f) * 100.0f;
+    }
+
+    public 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;
+    }
+}

decompiled/sources/androidx/core/content/res/ColorStateListInflaterCompat.java

@@ -0,0 +1,177 @@
+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.annotation.ColorInt;
+import androidx.annotation.ColorRes;
+import androidx.annotation.FloatRange;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.XmlRes;
+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;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public final class ColorStateListInflaterCompat {
+    private static final ThreadLocal<TypedValue> sTempTypedValue = new ThreadLocal<>();
+
+    private ColorStateListInflaterCompat() {
+    }
+
+    @Nullable
+    public static ColorStateList inflate(@NonNull Resources resources, @XmlRes int i, @Nullable Resources.Theme theme) {
+        try {
+            return createFromXml(resources, resources.getXml(i), theme);
+        } catch (Exception e) {
+            Log.e("CSLCompat", "Failed to inflate ColorStateList.", e);
+            return null;
+        }
+    }
+
+    @NonNull
+    public static ColorStateList createFromXml(@NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @Nullable 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);
+    }
+
+    @NonNull
+    public static ColorStateList createFromXmlInner(@NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @NonNull AttributeSet attributeSet, @Nullable 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(@NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @NonNull AttributeSet attributeSet, @Nullable 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(@NonNull Resources resources, @ColorRes int i) {
+        TypedValue typedValue = getTypedValue();
+        resources.getValue(i, typedValue, true);
+        int i2 = typedValue.type;
+        return i2 >= 28 && i2 <= 31;
+    }
+
+    @NonNull
+    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);
+    }
+
+    @ColorInt
+    private static int modulateColorAlpha(@ColorInt int i, @FloatRange(from = 0.0d, to = 1.0d) float f, @FloatRange(from = 0.0d, to = 100.0d) 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);
+    }
+}

decompiled/sources/androidx/core/content/res/ComplexColorCompat.java

@@ -0,0 +1,117 @@
+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 androidx.annotation.ColorInt;
+import androidx.annotation.ColorRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import java.io.IOException;
+import org.xmlpull.v1.XmlPullParserException;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* 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;
+
+    @ColorInt
+    public int getColor() {
+        return this.mColor;
+    }
+
+    @Nullable
+    public Shader getShader() {
+        return this.mShader;
+    }
+
+    public boolean isGradient() {
+        return this.mShader != null;
+    }
+
+    public void setColor(@ColorInt int i) {
+        this.mColor = i;
+    }
+
+    private ComplexColorCompat(Shader shader, ColorStateList colorStateList, @ColorInt int i) {
+        this.mShader = shader;
+        this.mColorStateList = colorStateList;
+        this.mColor = i;
+    }
+
+    public static ComplexColorCompat from(@NonNull Shader shader) {
+        return new ComplexColorCompat(shader, null, 0);
+    }
+
+    public static ComplexColorCompat from(@NonNull ColorStateList colorStateList) {
+        return new ComplexColorCompat(null, colorStateList, colorStateList.getDefaultColor());
+    }
+
+    public static ComplexColorCompat from(@ColorInt 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;
+    }
+
+    @Nullable
+    public static ComplexColorCompat inflate(@NonNull Resources resources, @ColorRes int i, @Nullable Resources.Theme theme) {
+        try {
+            return createFromXml(resources, i, theme);
+        } catch (Exception e) {
+            Log.e(LOG_TAG, "Failed to inflate ComplexColor.", e);
+            return null;
+        }
+    }
+
+    @NonNull
+    private static ComplexColorCompat createFromXml(@NonNull Resources resources, @ColorRes int i, @Nullable 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);
+    }
+}

decompiled/sources/androidx/core/content/res/ConfigurationHelper.java

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

decompiled/sources/androidx/core/content/res/FontResourcesParserCompat.java

@@ -0,0 +1,320 @@
+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.annotation.ArrayRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+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;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* 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 {
+
+        @Nullable
+        private final FontRequest mFallbackRequest;
+
+        @NonNull
+        private final FontRequest mRequest;
+        private final int mStrategy;
+
+        @Nullable
+        private final String mSystemFontFamilyName;
+        private final int mTimeoutMs;
+
+        @Nullable
+        public FontRequest getFallbackRequest() {
+            return this.mFallbackRequest;
+        }
+
+        public int getFetchStrategy() {
+            return this.mStrategy;
+        }
+
+        @NonNull
+        public FontRequest getRequest() {
+            return this.mRequest;
+        }
+
+        @Nullable
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public String getSystemFontFamilyName() {
+            return this.mSystemFontFamilyName;
+        }
+
+        public int getTimeout() {
+            return this.mTimeoutMs;
+        }
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public ProviderResourceEntry(@NonNull FontRequest fontRequest, @Nullable FontRequest fontRequest2, int i, int i2, @Nullable String str) {
+            this.mRequest = fontRequest;
+            this.mFallbackRequest = fontRequest2;
+            this.mStrategy = i;
+            this.mTimeoutMs = i2;
+            this.mSystemFontFamilyName = str;
+        }
+
+        public ProviderResourceEntry(@NonNull FontRequest fontRequest, int i, int i2) {
+            this(fontRequest, null, i, i2, null);
+        }
+    }
+
+    public static final class FontFileResourceEntry {
+
+        @NonNull
+        private final String mFileName;
+        private final boolean mItalic;
+        private final int mResourceId;
+        private final int mTtcIndex;
+        private final String mVariationSettings;
+        private final int mWeight;
+
+        @NonNull
+        public String getFileName() {
+            return this.mFileName;
+        }
+
+        public int getResourceId() {
+            return this.mResourceId;
+        }
+
+        public int getTtcIndex() {
+            return this.mTtcIndex;
+        }
+
+        @Nullable
+        public String getVariationSettings() {
+            return this.mVariationSettings;
+        }
+
+        public int getWeight() {
+            return this.mWeight;
+        }
+
+        public boolean isItalic() {
+            return this.mItalic;
+        }
+
+        public FontFileResourceEntry(@NonNull String str, int i, boolean z, @Nullable 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 {
+
+        @NonNull
+        private final FontFileResourceEntry[] mEntries;
+
+        @NonNull
+        public FontFileResourceEntry[] getEntries() {
+            return this.mEntries;
+        }
+
+        public FontFamilyFilesResourceEntry(@NonNull FontFileResourceEntry[] fontFileResourceEntryArr) {
+            this.mEntries = fontFileResourceEntryArr;
+        }
+    }
+
+    @Nullable
+    public static FamilyResourceEntry parse(@NonNull XmlPullParser xmlPullParser, @NonNull 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);
+    }
+
+    @Nullable
+    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;
+    }
+
+    @Nullable
+    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);
+        String string4 = obtainAttributes.getString(R.styleable.FontFamily_fontProviderFallbackQuery);
+        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, 500);
+        String string5 = obtainAttributes.getString(R.styleable.FontFamily_fontProviderSystemFontFamily);
+        obtainAttributes.recycle();
+        if (string != null && string2 != null && string3 != null) {
+            while (xmlPullParser.next() != 3) {
+                skip(xmlPullParser);
+            }
+            List<List<byte[]>> readCerts = readCerts(resources, resourceId);
+            return new ProviderResourceEntry(new FontRequest(string, string2, string3, readCerts), string4 != null ? new FontRequest(string, string2, string4, readCerts) : null, integer, integer2, string5);
+        }
+        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);
+    }
+
+    @NonNull
+    public static List<List<byte[]>> readCerts(@NonNull Resources resources, @ArrayRes 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, 400);
+        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() {
+    }
+
+    @RequiresApi(21)
+    public static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        public static int getType(TypedArray typedArray, int i) {
+            return typedArray.getType(i);
+        }
+    }
+}

decompiled/sources/androidx/core/content/res/GradientColorInflaterCompat.java

@@ -0,0 +1,204 @@
+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.annotation.ColorInt;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.core.R;
+import java.io.IOException;
+import java.util.List;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* 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() {
+    }
+
+    public static Shader createFromXml(@NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @Nullable 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 Shader createFromXmlInner(@NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @NonNull AttributeSet attributeSet, @Nullable 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(@androidx.annotation.NonNull android.content.res.Resources r8, @androidx.annotation.NonNull org.xmlpull.v1.XmlPullParser r9, @androidx.annotation.NonNull android.util.AttributeSet r10, @androidx.annotation.Nullable 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(@Nullable ColorStops colorStops, @ColorInt int i, @ColorInt int i2, boolean z, @ColorInt 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;
+    }
+
+    public static final class ColorStops {
+        final int[] mColors;
+        final float[] mOffsets;
+
+        public ColorStops(@NonNull List<Integer> list, @NonNull 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();
+            }
+        }
+
+        public ColorStops(@ColorInt int i, @ColorInt int i2) {
+            this.mColors = new int[]{i, i2};
+            this.mOffsets = new float[]{0.0f, 1.0f};
+        }
+
+        public ColorStops(@ColorInt int i, @ColorInt int i2, @ColorInt int i3) {
+            this.mColors = new int[]{i, i2, i3};
+            this.mOffsets = new float[]{0.0f, 0.5f, 1.0f};
+        }
+    }
+}

decompiled/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() {
+    }
+}

decompiled/sources/androidx/core/content/res/ResourcesCompat.java

@@ -0,0 +1,436 @@
+package androidx.core.content.res;
+
+import android.annotation.SuppressLint;
+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.annotation.AnyRes;
+import androidx.annotation.ColorInt;
+import androidx.annotation.ColorRes;
+import androidx.annotation.DimenRes;
+import androidx.annotation.DrawableRes;
+import androidx.annotation.FontRes;
+import androidx.annotation.GuardedBy;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+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 {
+
+    @AnyRes
+    public static final int ID_NULL = 0;
+    private static final String TAG = "ResourcesCompat";
+    private static final ThreadLocal<TypedValue> sTempTypedValue = new ThreadLocal<>();
+
+    @GuardedBy("sColorStateCacheLock")
+    private static final WeakHashMap<ColorStateListCacheKey, SparseArray<ColorStateListCacheEntry>> sColorStateCaches = new WeakHashMap<>(0);
+    private static final Object sColorStateCacheLock = new Object();
+
+    public static void clearCachesForTheme(@NonNull Resources.Theme theme) {
+        synchronized (sColorStateCacheLock) {
+            try {
+                Iterator<ColorStateListCacheKey> it = sColorStateCaches.keySet().iterator();
+                while (it.hasNext()) {
+                    ColorStateListCacheKey next = it.next();
+                    if (next != null && theme.equals(next.mTheme)) {
+                        it.remove();
+                    }
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Nullable
+    public static Drawable getDrawable(@NonNull Resources resources, @DrawableRes int i, @Nullable Resources.Theme theme) throws Resources.NotFoundException {
+        return Api21Impl.getDrawable(resources, i, theme);
+    }
+
+    @Nullable
+    public static Drawable getDrawableForDensity(@NonNull Resources resources, @DrawableRes int i, int i2, @Nullable Resources.Theme theme) throws Resources.NotFoundException {
+        return Api21Impl.getDrawableForDensity(resources, i, i2, theme);
+    }
+
+    @ColorInt
+    public static int getColor(@NonNull Resources resources, @ColorRes int i, @Nullable Resources.Theme theme) throws Resources.NotFoundException {
+        return Api23Impl.getColor(resources, i, theme);
+    }
+
+    @Nullable
+    public static ColorStateList getColorStateList(@NonNull Resources resources, @ColorRes int i, @Nullable 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;
+        }
+        return Api23Impl.getColorStateList(resources, i, theme);
+    }
+
+    @Nullable
+    private static ColorStateList inflateColorStateList(Resources resources, int i, @Nullable 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;
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:23:0x003c, code lost:
+    
+        if (r2.mThemeHash == r5.hashCode()) goto L22;
+     */
+    @androidx.annotation.Nullable
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static android.content.res.ColorStateList getCachedColorStateList(@androidx.annotation.NonNull androidx.core.content.res.ResourcesCompat.ColorStateListCacheKey r5, @androidx.annotation.ColorRes int r6) {
+        /*
+            java.lang.Object r0 = androidx.core.content.res.ResourcesCompat.sColorStateCacheLock
+            monitor-enter(r0)
+            java.util.WeakHashMap<androidx.core.content.res.ResourcesCompat$ColorStateListCacheKey, android.util.SparseArray<androidx.core.content.res.ResourcesCompat$ColorStateListCacheEntry>> r1 = androidx.core.content.res.ResourcesCompat.sColorStateCaches     // Catch: java.lang.Throwable -> L32
+            java.lang.Object r1 = r1.get(r5)     // Catch: java.lang.Throwable -> L32
+            android.util.SparseArray r1 = (android.util.SparseArray) r1     // Catch: java.lang.Throwable -> L32
+            if (r1 == 0) goto L45
+            int r2 = r1.size()     // Catch: java.lang.Throwable -> L32
+            if (r2 <= 0) goto L45
+            java.lang.Object r2 = r1.get(r6)     // Catch: java.lang.Throwable -> L32
+            androidx.core.content.res.ResourcesCompat$ColorStateListCacheEntry r2 = (androidx.core.content.res.ResourcesCompat.ColorStateListCacheEntry) r2     // Catch: java.lang.Throwable -> L32
+            if (r2 == 0) goto L45
+            android.content.res.Configuration r3 = r2.mConfiguration     // Catch: java.lang.Throwable -> L32
+            android.content.res.Resources r4 = r5.mResources     // Catch: java.lang.Throwable -> L32
+            android.content.res.Configuration r4 = r4.getConfiguration()     // Catch: java.lang.Throwable -> L32
+            boolean r3 = r3.equals(r4)     // Catch: java.lang.Throwable -> L32
+            if (r3 == 0) goto L42
+            android.content.res.Resources$Theme r5 = r5.mTheme     // Catch: java.lang.Throwable -> L32
+            if (r5 != 0) goto L34
+            int r3 = r2.mThemeHash     // Catch: java.lang.Throwable -> L32
+            if (r3 == 0) goto L3e
+            goto L34
+        L32:
+            r5 = move-exception
+            goto L48
+        L34:
+            if (r5 == 0) goto L42
+            int r3 = r2.mThemeHash     // Catch: java.lang.Throwable -> L32
+            int r5 = r5.hashCode()     // Catch: java.lang.Throwable -> L32
+            if (r3 != r5) goto L42
+        L3e:
+            android.content.res.ColorStateList r5 = r2.mValue     // Catch: java.lang.Throwable -> L32
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L32
+            return r5
+        L42:
+            r1.remove(r6)     // Catch: java.lang.Throwable -> L32
+        L45:
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L32
+            r5 = 0
+            return r5
+        L48:
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L32
+            throw r5
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.core.content.res.ResourcesCompat.getCachedColorStateList(androidx.core.content.res.ResourcesCompat$ColorStateListCacheKey, int):android.content.res.ColorStateList");
+    }
+
+    private static void addColorStateListToCache(@NonNull ColorStateListCacheKey colorStateListCacheKey, @ColorRes int i, @NonNull ColorStateList colorStateList, @Nullable Resources.Theme theme) {
+        synchronized (sColorStateCacheLock) {
+            try {
+                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));
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    private static boolean isColorInt(@NonNull Resources resources, @ColorRes int i) {
+        TypedValue typedValue = getTypedValue();
+        resources.getValue(i, typedValue, true);
+        int i2 = typedValue.type;
+        return i2 >= 28 && i2 <= 31;
+    }
+
+    @NonNull
+    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;
+    }
+
+    public static final class ColorStateListCacheKey {
+        final Resources mResources;
+        final Resources.Theme mTheme;
+
+        public ColorStateListCacheKey(@NonNull Resources resources, @Nullable Resources.Theme theme) {
+            this.mResources = resources;
+            this.mTheme = theme;
+        }
+
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (obj == null || ColorStateListCacheKey.class != 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);
+        }
+    }
+
+    public static class ColorStateListCacheEntry {
+        final Configuration mConfiguration;
+        final int mThemeHash;
+        final ColorStateList mValue;
+
+        public ColorStateListCacheEntry(@NonNull ColorStateList colorStateList, @NonNull Configuration configuration, @Nullable Resources.Theme theme) {
+            this.mValue = colorStateList;
+            this.mConfiguration = configuration;
+            this.mThemeHash = theme == null ? 0 : theme.hashCode();
+        }
+    }
+
+    public static float getFloat(@NonNull Resources resources, @DimenRes 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");
+    }
+
+    @Nullable
+    public static Typeface getFont(@NonNull Context context, @FontRes int i) throws Resources.NotFoundException {
+        if (context.isRestricted()) {
+            return null;
+        }
+        return loadFont(context, i, new TypedValue(), 0, null, null, false, false);
+    }
+
+    @Nullable
+    public static Typeface getCachedFont(@NonNull Context context, @FontRes 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 lambda$callbackFailAsync$1(int i);
+
+        /* renamed from: onFontRetrieved, reason: merged with bridge method [inline-methods] */
+        public abstract void lambda$callbackSuccessAsync$0(@NonNull Typeface typeface);
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+        public final void callbackSuccessAsync(@NonNull final Typeface typeface, @Nullable 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.lambda$callbackSuccessAsync$0(typeface);
+                }
+            });
+        }
+
+        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+        public final void callbackFailAsync(final int i, @Nullable 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.lambda$callbackFailAsync$1(i);
+                }
+            });
+        }
+
+        @NonNull
+        @RestrictTo({RestrictTo.Scope.LIBRARY})
+        public static Handler getHandler(@Nullable Handler handler) {
+            return handler == null ? new Handler(Looper.getMainLooper()) : handler;
+        }
+    }
+
+    public static void getFont(@NonNull Context context, @FontRes int i, @NonNull FontCallback fontCallback, @Nullable 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);
+        }
+    }
+
+    @Nullable
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static Typeface getFont(@NonNull Context context, @FontRes int i, @NonNull TypedValue typedValue, int i2, @Nullable FontCallback fontCallback) throws Resources.NotFoundException {
+        if (context.isRestricted()) {
+            return null;
+        }
+        return loadFont(context, i, typedValue, i2, fontCallback, null, true, false);
+    }
+
+    private static Typeface loadFont(@NonNull Context context, int i, @NonNull TypedValue typedValue, int i2, @Nullable FontCallback fontCallback, @Nullable 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:40:0x00c1  */
+    /* JADX WARN: Removed duplicated region for block: B:42:? A[RETURN, SYNTHETIC] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static android.graphics.Typeface loadFont(@androidx.annotation.NonNull android.content.Context r16, android.content.res.Resources r17, @androidx.annotation.NonNull android.util.TypedValue r18, int r19, int r20, @androidx.annotation.Nullable androidx.core.content.res.ResourcesCompat.FontCallback r21, @androidx.annotation.Nullable android.os.Handler r22, boolean r23, boolean r24) {
+        /*
+            Method dump skipped, instructions count: 245
+            To view this dump add '--comments-level debug' option
+        */
+        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");
+    }
+
+    @RequiresApi(29)
+    public static class Api29Impl {
+        private Api29Impl() {
+        }
+
+        public static float getFloat(@NonNull Resources resources, @DimenRes int i) {
+            return resources.getFloat(i);
+        }
+    }
+
+    @RequiresApi(23)
+    public static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        @NonNull
+        public static ColorStateList getColorStateList(@NonNull Resources resources, @ColorRes int i, @Nullable Resources.Theme theme) {
+            return resources.getColorStateList(i, theme);
+        }
+
+        public static int getColor(Resources resources, int i, Resources.Theme theme) {
+            return resources.getColor(i, theme);
+        }
+    }
+
+    @RequiresApi(21)
+    public static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        public static Drawable getDrawable(Resources resources, int i, Resources.Theme theme) {
+            return resources.getDrawable(i, theme);
+        }
+
+        public static Drawable getDrawableForDensity(Resources resources, int i, int i2, Resources.Theme theme) {
+            return resources.getDrawableForDensity(i, i2, theme);
+        }
+    }
+
+    private ResourcesCompat() {
+    }
+
+    public static final class ThemeCompat {
+        private ThemeCompat() {
+        }
+
+        public static void rebase(@NonNull Resources.Theme theme) {
+            if (Build.VERSION.SDK_INT >= 29) {
+                Api29Impl.rebase(theme);
+            } else {
+                Api23Impl.rebase(theme);
+            }
+        }
+
+        @RequiresApi(29)
+        public static class Api29Impl {
+            private Api29Impl() {
+            }
+
+            public static void rebase(@NonNull Resources.Theme theme) {
+                theme.rebase();
+            }
+        }
+
+        @RequiresApi(23)
+        public static class Api23Impl {
+            private static Method sRebaseMethod;
+            private static boolean sRebaseMethodFetched;
+            private static final Object sRebaseMethodLock = new Object();
+
+            private Api23Impl() {
+            }
+
+            @SuppressLint({"BanUncheckedReflection"})
+            public static void rebase(@NonNull 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 unused) {
+                        }
+                        sRebaseMethodFetched = true;
+                    }
+                    Method method = sRebaseMethod;
+                    if (method != null) {
+                        try {
+                            method.invoke(theme, new Object[0]);
+                        } catch (IllegalAccessException | InvocationTargetException unused2) {
+                            sRebaseMethod = null;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

decompiled/sources/androidx/core/content/res/TypedArrayApi26ImplKt.java

@@ -0,0 +1,22 @@
+package androidx.core.content.res;
+
+import android.content.res.TypedArray;
+import android.graphics.Typeface;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.StyleableRes;
+import kotlin.jvm.internal.Intrinsics;
+
+@RequiresApi(26)
+/* loaded from: classes.dex */
+final class TypedArrayApi26ImplKt {
+    public static final TypedArrayApi26ImplKt INSTANCE = new TypedArrayApi26ImplKt();
+
+    private TypedArrayApi26ImplKt() {
+    }
+
+    public static final Typeface getFont(TypedArray typedArray, @StyleableRes int i) {
+        Typeface font = typedArray.getFont(i);
+        Intrinsics.checkNotNull(font);
+        return font;
+    }
+}